adhdev 0.9.44 → 0.9.45

package/dist/index.js

@@ -890,17 +890,17 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs(providerLoader) {
-  const os29 = (0, import_os2.platform)();
+  const os28 = (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[os29] || []) || []);
+    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os28] || []) || []);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os29 === "darwin") {
+    if (!resolvedCli && appPath && os28 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs3.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os29 === "win32") {
+    if (!resolvedCli && appPath && os28 === "win32") {
       const { dirname: dirname10 } = await import("path");
       const appDir = dirname10(appPath);
       const candidates = [
@@ -917,7 +917,7 @@ async function detectIDEs(providerLoader) {
         }
       }
     }
-    const installed = os29 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
+    const installed = os28 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
     const version2 = resolvedCli ? getIdeVersion(resolvedCli) : null;
     results.push({
       id: def.id,
@@ -986,8 +986,8 @@ function execAsync(cmd, timeoutMs = 5e3) {
   });
 }
 async function detectCLIs(providerLoader, options) {
-  const platform13 = os2.platform();
-  const whichCmd = platform13 === "win32" ? "where" : "which";
+  const platform12 = os2.platform();
+  const whichCmd = platform12 === "win32" ? "where" : "which";
   const includeVersion = options?.includeVersion !== false;
   const cliList = providerLoader ? providerLoader.getCliDetectionList() : [];
   const results = await Promise.all(
@@ -1030,8 +1030,8 @@ async function detectCLI(cliId, providerLoader, options) {
     const cliList = providerLoader.getCliDetectionList();
     const target = cliList.find((c) => c.id === resolvedId);
     if (target) {
-      const platform13 = os2.platform();
-      const whichCmd = platform13 === "win32" ? "where" : "which";
+      const platform12 = os2.platform();
+      const whichCmd = platform12 === "win32" ? "where" : "which";
       try {
         const explicitPath = resolveCommandPath(target.command);
         const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(target.command)}`);
@@ -4032,6 +4032,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, "_");
@@ -4057,25 +4078,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 };
   }
@@ -4210,6 +4213,52 @@ function rewriteCanonicalSavedHistory(agentType, historySessionId, records) {
     return false;
   }
 }
+function buildHermesNativeHistoryRecords(historySessionId) {
+  const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
+  if (!normalizedSessionId) return null;
+  try {
+    const sessionFilePath = path7.join(os5.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;
@@ -4359,6 +4408,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;
@@ -4437,6 +4557,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(os5.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(os5.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(os5.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(os5.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, os5, 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"() {
@@ -5440,6 +5906,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;
@@ -7707,7 +8175,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 };
@@ -7732,7 +8209,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,
@@ -7742,6 +8220,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({
@@ -7760,7 +8240,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);
       }
     }
@@ -10552,18 +11034,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,
@@ -10936,14 +11418,14 @@ function applyTerminalColorEnv(env3) {
 function ensureNodePtySpawnHelperPermissions(logFn) {
   if (os22.platform() === "win32") return;
   try {
-    const fs24 = __require("fs");
+    const fs19 = __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 (fs24.existsSync(helper)) {
-      const stat4 = fs24.statSync(helper);
+    if (fs19.existsSync(helper)) {
+      const stat4 = fs19.statSync(helper);
       if (!(stat4.mode & 73)) {
-        fs24.chmodSync(helper, stat4.mode | 493);
+        fs19.chmodSync(helper, stat4.mode | 493);
         logFn?.(`Fixed spawn-helper permissions: ${helper}`);
       }
     }
@@ -11138,8 +11620,8 @@ var init_pty_transport = __esm({
         let cwd = options.cwd;
         if (cwd) {
           try {
-            const fs24 = require("fs");
-            const stat4 = fs24.statSync(cwd);
+            const fs19 = require("fs");
+            const stat4 = fs19.statSync(cwd);
             if (!stat4.isDirectory()) cwd = os9.homedir();
           } catch {
             cwd = os9.homedir();
@@ -11237,12 +11719,12 @@ function findBinary(name) {
 function isScriptBinary(binaryPath) {
   if (!path9.isAbsolute(binaryPath)) return false;
   try {
-    const fs24 = require("fs");
-    const resolved = fs24.realpathSync(binaryPath);
+    const fs19 = require("fs");
+    const resolved = fs19.realpathSync(binaryPath);
     const head = Buffer.alloc(8);
-    const fd = fs24.openSync(resolved, "r");
-    fs24.readSync(fd, head, 0, 8, 0);
-    fs24.closeSync(fd);
+    const fd = fs19.openSync(resolved, "r");
+    fs19.readSync(fd, head, 0, 8, 0);
+    fs19.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;
@@ -11253,12 +11735,12 @@ function isScriptBinary(binaryPath) {
 function looksLikeMachOOrElf(filePath) {
   if (!path9.isAbsolute(filePath)) return false;
   try {
-    const fs24 = require("fs");
-    const resolved = fs24.realpathSync(filePath);
+    const fs19 = require("fs");
+    const resolved = fs19.realpathSync(filePath);
     const buf = Buffer.alloc(8);
-    const fd = fs24.openSync(resolved, "r");
-    fs24.readSync(fd, buf, 0, 8, 0);
-    fs24.closeSync(fd);
+    const fd = fs19.openSync(resolved, "r");
+    fs19.readSync(fd, buf, 0, 8, 0);
+    fs19.closeSync(fd);
     let i = 0;
     if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
     const b = buf.subarray(i);
@@ -11818,7 +12300,8 @@ __export(provider_cli_adapter_exports, {
   ProviderCliAdapter: () => ProviderCliAdapter,
   appendBoundedText: () => appendBoundedText,
   normalizeCliProviderForRuntime: () => normalizeCliProviderForRuntime,
-  sanitizeCliStandardMessageContent: () => sanitizeCliStandardMessageContent
+  sanitizeCliStandardMessageContent: () => sanitizeCliStandardMessageContent,
+  trimLastAssistantEchoForCliMessages: () => trimLastAssistantEchoForCliMessages
 });
 function normalizeComparableTranscriptText(value) {
   return sanitizeTerminalText(String(value || "")).replace(/\s+/g, " ").trim();
@@ -11914,6 +12397,19 @@ function sanitizeCommittedMessageForDisplay(message) {
   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 os12, COMMITTED_ACTIVITY_PREFIX_BLOCK_RE, ProviderCliAdapter;
 var init_provider_cli_adapter = __esm({
   "../../oss/packages/daemon-core/src/cli-adapters/provider-cli-adapter.ts"() {
@@ -12111,7 +12607,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);
       }
@@ -12594,9 +13097,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) {
@@ -13450,7 +13951,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];
@@ -14342,6 +14844,8 @@ var init_cli_provider_instance = __esm({
       lastCanonicalHermesWatchPath = void 0;
       lastCanonicalClaudeRebuildMtimeMs = 0;
       lastCanonicalClaudeCheckAt = 0;
+      lastCanonicalCodexRebuildMtimeMs = 0;
+      lastCanonicalCodexCheckAt = 0;
       cachedSqliteDb = null;
       cachedSqliteDbPath = null;
       cachedSqliteDbMissingUntil = 0;
@@ -15041,6 +15545,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") {
@@ -15074,6 +15597,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);
@@ -15092,8 +15632,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,
@@ -15420,10 +15969,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path29) {
-  if (!path29)
+function getElementAtPath(obj, path28) {
+  if (!path28)
     return obj;
-  return path29.reduce((acc, key) => acc?.[key], obj);
+  return path28.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -15735,11 +16284,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path29, issues) {
+function prefixIssues(path28, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path29);
+    iss.path.unshift(path28);
     return iss;
   });
 }
@@ -15982,7 +16531,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path29 = []) => {
+  const processError = (error49, path28 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -15992,7 +16541,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path29, ...issue2.path];
+        const fullpath = [...path28, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -16024,8 +16573,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path29 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path29) {
+  const path28 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path28) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -28789,13 +29338,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path29 = ref.slice(1).split("/").filter(Boolean);
-  if (path29.length === 0) {
+  const path28 = ref.slice(1).split("/").filter(Boolean);
+  if (path28.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path29[0] === defsKey) {
-    const key = path29[1];
+  if (path28[0] === defsKey) {
+    const key = path28[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -33549,7 +34098,7 @@ var init_readdirp = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
         if (wantBigintFsStats) {
-          this._stat = (path29) => statMethod(path29, { bigint: true });
+          this._stat = (path28) => statMethod(path28, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -33574,8 +34123,8 @@ var init_readdirp = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path29, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path29));
+              const { path: path28, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path28));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -33615,21 +34164,21 @@ var init_readdirp = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path29, depth) {
+      async _exploreDir(path28, depth) {
         let files;
         try {
-          files = await (0, import_promises.readdir)(path29, this._rdOptions);
+          files = await (0, import_promises.readdir)(path28, this._rdOptions);
         } catch (error48) {
           this._onError(error48);
         }
-        return { files, depth, path: path29 };
+        return { files, depth, path: path28 };
       }
-      async _formatEntry(dirent, path29) {
+      async _formatEntry(dirent, path28) {
         let entry;
-        const basename9 = this._isDirent ? dirent.name : dirent;
+        const basename10 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path29, basename9));
-          entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename9 };
+          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path28, basename10));
+          entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename10 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
           this._onError(err);
@@ -33685,16 +34234,16 @@ var init_readdirp = __esm({
 });
 
 // ../../oss/packages/daemon-core/node_modules/chokidar/handler.js
-function createFsWatchInstance(path29, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path28, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path29);
-    emitRaw(rawEvent, evPath, { watchedPath: path29 });
-    if (evPath && path29 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path29, evPath), KEY_LISTENERS, sp.join(path29, evPath));
+    listener(path28);
+    emitRaw(rawEvent, evPath, { watchedPath: path28 });
+    if (evPath && path28 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path28, evPath), KEY_LISTENERS, sp.join(path28, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path29, {
+    return (0, import_node_fs.watch)(path28, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error48) {
@@ -34043,12 +34592,12 @@ var init_handler2 = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path29, fullPath, options, handlers) => {
+    setFsWatchListener = (path28, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path29, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path28, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -34059,7 +34608,7 @@ var init_handler2 = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path29,
+          path28,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -34074,7 +34623,7 @@ var init_handler2 = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error48.code === "EPERM") {
             try {
-              const fd = await (0, import_promises2.open)(path29, "r");
+              const fd = await (0, import_promises2.open)(path28, "r");
               await fd.close();
               broadcastErr(error48);
             } catch (err) {
@@ -34105,7 +34654,7 @@ var init_handler2 = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path29, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path28, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -34127,7 +34676,7 @@ var init_handler2 = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path29, curr));
+              foreach(cont.listeners, (listener2) => listener2(path28, curr));
             }
           })
         };
@@ -34157,13 +34706,13 @@ var init_handler2 = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path29, listener) {
+      _watchWithNodeFs(path28, listener) {
         const opts = this.fsw.options;
-        const directory = sp.dirname(path29);
-        const basename9 = sp.basename(path29);
+        const directory = sp.dirname(path28);
+        const basename10 = sp.basename(path28);
         const parent = this.fsw._getWatchedDir(directory);
-        parent.add(basename9);
-        const absolutePath = sp.resolve(path29);
+        parent.add(basename10);
+        const absolutePath = sp.resolve(path28);
         const options = {
           persistent: opts.persistent
         };
@@ -34172,13 +34721,13 @@ var init_handler2 = __esm({
         let closer;
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
-          options.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path29, absolutePath, options, {
+          options.interval = enableBin && isBinaryPath(basename10) ? opts.binaryInterval : opts.interval;
+          closer = setFsWatchFileListener(path28, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path29, absolutePath, options, {
+          closer = setFsWatchListener(path28, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -34195,12 +34744,12 @@ var init_handler2 = __esm({
           return;
         }
         const dirname10 = sp.dirname(file2);
-        const basename9 = sp.basename(file2);
+        const basename10 = sp.basename(file2);
         const parent = this.fsw._getWatchedDir(dirname10);
         let prevStats = stats;
-        if (parent.has(basename9))
+        if (parent.has(basename10))
           return;
-        const listener = async (path29, newStats) => {
+        const listener = async (path28, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -34214,18 +34763,18 @@ var init_handler2 = __esm({
                 this.fsw._emit(EV.CHANGE, file2, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path29);
+                this.fsw._closeFile(path28);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file2, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path29, closer2);
+                  this.fsw._addPathCloser(path28, closer2);
               } else {
                 prevStats = newStats2;
               }
             } catch (error48) {
-              this.fsw._remove(dirname10, basename9);
+              this.fsw._remove(dirname10, basename10);
             }
-          } else if (parent.has(basename9)) {
+          } else if (parent.has(basename10)) {
             const at = newStats.atimeMs;
             const mt = newStats.mtimeMs;
             if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -34250,7 +34799,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, path29, item) {
+      async _handleSymlink(entry, directory, path28, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -34260,7 +34809,7 @@ var init_handler2 = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await (0, import_promises2.realpath)(path29);
+            linkPath = await (0, import_promises2.realpath)(path28);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -34270,12 +34819,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, path29, entry.stats);
+              this.fsw._emit(EV.CHANGE, path28, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path29, entry.stats);
+            this.fsw._emit(EV.ADD, path28, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -34305,9 +34854,9 @@ var init_handler2 = __esm({
             return;
           }
           const item = entry.path;
-          let path29 = sp.join(directory, item);
+          let path28 = sp.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path29, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path28, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -34316,8 +34865,8 @@ var init_handler2 = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path29 = sp.join(dir, sp.relative(dir, path29));
-            this._addToNodeFs(path29, initialAdd, wh, depth + 1);
+            path28 = sp.join(dir, sp.relative(dir, path28));
+            this._addToNodeFs(path28, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve16, reject) => {
@@ -34386,13 +34935,13 @@ var init_handler2 = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path29, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path28, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path29) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path28) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path29);
+        const wh = this.fsw._getWatchHelpers(path28);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -34408,8 +34957,8 @@ var init_handler2 = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sp.resolve(path29);
-            const targetPath = follow ? await (0, import_promises2.realpath)(path29) : path29;
+            const absPath = sp.resolve(path28);
+            const targetPath = follow ? await (0, import_promises2.realpath)(path28) : path28;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -34419,29 +34968,29 @@ var init_handler2 = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await (0, import_promises2.realpath)(path29) : path29;
+            const targetPath = follow ? await (0, import_promises2.realpath)(path28) : path28;
             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, path29, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path28, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sp.resolve(path29), targetPath);
+              this.fsw._symlinkPaths.set(sp.resolve(path28), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path29, closer);
+            this.fsw._addPathCloser(path28, closer);
           return false;
         } catch (error48) {
           if (this.fsw._handleError(error48)) {
             ready();
-            return path29;
+            return path28;
           }
         }
       }
@@ -34476,24 +35025,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path29) {
-  if (typeof path29 !== "string")
+function normalizePath(path28) {
+  if (typeof path28 !== "string")
     throw new Error("string expected");
-  path29 = sp2.normalize(path29);
-  path29 = path29.replace(/\\/g, "/");
+  path28 = sp2.normalize(path28);
+  path28 = path28.replace(/\\/g, "/");
   let prepend = false;
-  if (path29.startsWith("//"))
+  if (path28.startsWith("//"))
     prepend = true;
-  path29 = path29.replace(DOUBLE_SLASH_RE, "/");
+  path28 = path28.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path29 = "/" + path29;
-  return path29;
+    path28 = "/" + path28;
+  return path28;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path29 = normalizePath(testString);
+  const path28 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path29, stats)) {
+    if (pattern(path28, stats)) {
       return true;
     }
   }
@@ -34556,19 +35105,19 @@ var init_chokidar = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path29) => toUnix(sp2.normalize(toUnix(path29)));
-    normalizeIgnored = (cwd = "") => (path29) => {
-      if (typeof path29 === "string") {
-        return normalizePathToUnix(sp2.isAbsolute(path29) ? path29 : sp2.join(cwd, path29));
+    normalizePathToUnix = (path28) => toUnix(sp2.normalize(toUnix(path28)));
+    normalizeIgnored = (cwd = "") => (path28) => {
+      if (typeof path28 === "string") {
+        return normalizePathToUnix(sp2.isAbsolute(path28) ? path28 : sp2.join(cwd, path28));
       } else {
-        return path29;
+        return path28;
       }
     };
-    getAbsolutePath = (path29, cwd) => {
-      if (sp2.isAbsolute(path29)) {
-        return path29;
+    getAbsolutePath = (path28, cwd) => {
+      if (sp2.isAbsolute(path28)) {
+        return path28;
       }
-      return sp2.join(cwd, path29);
+      return sp2.join(cwd, path28);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -34633,10 +35182,10 @@ var init_chokidar = __esm({
       dirParts;
       followSymlinks;
       statMethod;
-      constructor(path29, follow, fsw) {
+      constructor(path28, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path29;
-        this.path = path29 = path29.replace(REPLACER_RE, "");
+        const watchPath = path28;
+        this.path = path28 = path28.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sp2.resolve(watchPath);
         this.dirParts = [];
@@ -34776,20 +35325,20 @@ var init_chokidar = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path29) => {
-            const absPath = getAbsolutePath(path29, cwd);
+          paths = paths.map((path28) => {
+            const absPath = getAbsolutePath(path28, cwd);
             return absPath;
           });
         }
-        paths.forEach((path29) => {
-          this._removeIgnoredPath(path29);
+        paths.forEach((path28) => {
+          this._removeIgnoredPath(path28);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path29) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path29, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path28) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path28, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -34811,17 +35360,17 @@ var init_chokidar = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path29) => {
-          if (!sp2.isAbsolute(path29) && !this._closers.has(path29)) {
+        paths.forEach((path28) => {
+          if (!sp2.isAbsolute(path28) && !this._closers.has(path28)) {
             if (cwd)
-              path29 = sp2.join(cwd, path29);
-            path29 = sp2.resolve(path29);
+              path28 = sp2.join(cwd, path28);
+            path28 = sp2.resolve(path28);
           }
-          this._closePath(path29);
-          this._addIgnoredPath(path29);
-          if (this._watched.has(path29)) {
+          this._closePath(path28);
+          this._addIgnoredPath(path28);
+          if (this._watched.has(path28)) {
             this._addIgnoredPath({
-              path: path29,
+              path: path28,
               recursive: true
             });
           }
@@ -34885,38 +35434,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, path29, stats) {
+      async _emit(event, path28, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path29 = sp2.normalize(path29);
+          path28 = sp2.normalize(path28);
         if (opts.cwd)
-          path29 = sp2.relative(opts.cwd, path29);
-        const args = [path29];
+          path28 = sp2.relative(opts.cwd, path28);
+        const args = [path28];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path29))) {
+        if (awf && (pw = this._pendingWrites.get(path28))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path29, [event, ...args]);
+            this._pendingUnlinks.set(path28, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path30) => {
+              this._pendingUnlinks.forEach((entry, path29) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path30);
+                this._pendingUnlinks.delete(path29);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path29)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path28)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path29);
+            this._pendingUnlinks.delete(path28);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -34934,16 +35483,16 @@ var init_chokidar = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path29, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path28, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path29, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path28, 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, path29) : path29;
+          const fullPath = opts.cwd ? sp2.join(opts.cwd, path28) : path28;
           let stats2;
           try {
             stats2 = await (0, import_promises3.stat)(fullPath);
@@ -34974,23 +35523,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, path29, timeout) {
+      _throttle(actionType, path28, 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(path29);
+        const actionPath = action.get(path28);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path29);
+          const item = action.get(path28);
           const count = item ? item.count : 0;
-          action.delete(path29);
+          action.delete(path28);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -34998,7 +35547,7 @@ var init_chokidar = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path29, thr);
+        action.set(path28, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -35012,44 +35561,44 @@ var init_chokidar = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path29, threshold, event, awfEmit) {
+      _awaitWriteFinish(path28, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path29;
-        if (this.options.cwd && !sp2.isAbsolute(path29)) {
-          fullPath = sp2.join(this.options.cwd, path29);
+        let fullPath = path28;
+        if (this.options.cwd && !sp2.isAbsolute(path28)) {
+          fullPath = sp2.join(this.options.cwd, path28);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-            if (err || !writes.has(path29)) {
+            if (err || !writes.has(path28)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path29).lastChange = now2;
+              writes.get(path28).lastChange = now2;
             }
-            const pw = writes.get(path29);
+            const pw = writes.get(path28);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path29);
+              writes.delete(path28);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path29)) {
-          writes.set(path29, {
+        if (!writes.has(path28)) {
+          writes.set(path28, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path29);
+              writes.delete(path28);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -35060,8 +35609,8 @@ var init_chokidar = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path29, stats) {
-        if (this.options.atomic && DOT_RE.test(path29))
+      _isIgnored(path28, stats) {
+        if (this.options.atomic && DOT_RE.test(path28))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -35071,17 +35620,17 @@ var init_chokidar = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path29, stats);
+        return this._userIgnored(path28, stats);
       }
-      _isntIgnored(path29, stat4) {
-        return !this._isIgnored(path29, stat4);
+      _isntIgnored(path28, stat4) {
+        return !this._isIgnored(path28, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path29) {
-        return new WatchHelper(path29, this.options.followSymlinks, this);
+      _getWatchHelpers(path28) {
+        return new WatchHelper(path28, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -35113,63 +35662,63 @@ var init_chokidar = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path29 = sp2.join(directory, item);
-        const fullPath = sp2.resolve(path29);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path29) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path29, 100))
+        const path28 = sp2.join(directory, item);
+        const fullPath = sp2.resolve(path28);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path28) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path28, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path29);
+        const wp = this._getWatchedDir(path28);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path29, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path28, 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 = path29;
+        let relPath = path28;
         if (this.options.cwd)
-          relPath = sp2.relative(this.options.cwd, path29);
+          relPath = sp2.relative(this.options.cwd, path28);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path29);
+        this._watched.delete(path28);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path29))
-          this._emit(eventName, path29);
-        this._closePath(path29);
+        if (wasTracked && !this._isIgnored(path28))
+          this._emit(eventName, path28);
+        this._closePath(path28);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path29) {
-        this._closeFile(path29);
-        const dir = sp2.dirname(path29);
-        this._getWatchedDir(dir).remove(sp2.basename(path29));
+      _closePath(path28) {
+        this._closeFile(path28);
+        const dir = sp2.dirname(path28);
+        this._getWatchedDir(dir).remove(sp2.basename(path28));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path29) {
-        const closers = this._closers.get(path29);
+      _closeFile(path28) {
+        const closers = this._closers.get(path28);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path29);
+        this._closers.delete(path28);
       }
-      _addPathCloser(path29, closer) {
+      _addPathCloser(path28, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path29);
+        let list = this._closers.get(path28);
         if (!list) {
           list = [];
-          this._closers.set(path29, list);
+          this._closers.set(path28, list);
         }
         list.push(closer);
       }
@@ -36918,6 +37467,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) {
@@ -36940,9 +37526,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) {
@@ -36953,6 +37539,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);
@@ -37014,6 +37629,7 @@ async function killIdeProcess(ideId) {
         } catch {
         }
       }
+      killMacAppPathProcesses(ideId, "SIGTERM");
     } else if (plat === "win32" && winProcesses) {
       for (const proc of winProcesses) {
         try {
@@ -37043,6 +37659,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 {
@@ -37062,14 +37679,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)}")'`,
           {
@@ -37078,8 +37697,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;
@@ -37124,7 +37745,7 @@ function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs24 = require("fs");
+      const fs19 = require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
@@ -37133,8 +37754,8 @@ function detectCurrentWorkspace(ideId) {
           appName,
           "storage.json"
         );
-        if (fs24.existsSync(storagePath)) {
-          const data = JSON.parse(fs24.readFileSync(storagePath, "utf-8"));
+        if (fs19.existsSync(storagePath)) {
+          const data = JSON.parse(fs19.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -37151,7 +37772,7 @@ function detectCurrentWorkspace(ideId) {
   return void 0;
 }
 async function launchWithCdp(options = {}) {
-  const platform13 = os16.platform();
+  const platform12 = os16.platform();
   let targetIde;
   const ides = await detectIDEs(getProviderLoader());
   if (options.ideId) {
@@ -37220,9 +37841,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);
@@ -37310,6 +37931,7 @@ var init_launch = __esm({
     path14 = __toESM(require("path"));
     init_ide_detector();
     init_provider_loader();
+    init_macos_app_process();
     _providerLoader = null;
   }
 });
@@ -38502,13 +39124,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,
@@ -38531,7 +39158,8 @@ var init_router = __esm({
                   canResume: !!(saved?.workspace || recent?.workspace || session.workspace) && canResumeById
                 };
               }),
-              hasMore
+              hasMore,
+              source
             };
           }
           // ─── restart_session: IDE / CLI / ACP unified ───
@@ -44567,8 +45195,8 @@ var init_dev_server = __esm({
       }
       getEndpointList() {
         return this.routes.map((r) => {
-          const path29 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-          return `${r.method.padEnd(5)} ${path29}`;
+          const path28 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+          return `${r.method.padEnd(5)} ${path28}`;
         });
       }
       async start(port = DEV_SERVER_PORT) {
@@ -46510,8 +47138,8 @@ async function installExtension(ide, extension) {
       const res = await fetch(extension.vsixUrl);
       if (res.ok) {
         const buffer = Buffer.from(await res.arrayBuffer());
-        const fs24 = await import("fs");
-        fs24.writeFileSync(vsixPath, buffer);
+        const fs19 = await import("fs");
+        fs19.writeFileSync(vsixPath, buffer);
         return new Promise((resolve16) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
           (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
@@ -48467,9 +49095,9 @@ 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 = [
             path23.join(__dirname, "node_modules", "node-datachannel"),
@@ -48849,27 +49477,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "../../node_modules/detect-libc/lib/filesystem.js"(exports2, module2) {
     "use strict";
-    var fs24 = require("fs");
+    var fs19 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync19 = (path29) => {
-      const fd = fs24.openSync(path29, "r");
+    var readFileSync19 = (path28) => {
+      const fd = fs19.openSync(path28, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs24.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs24.close(fd, () => {
+      const bytesRead = fs19.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs19.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path29) => new Promise((resolve16, reject) => {
-      fs24.open(path29, "r", (err, fd) => {
+    var readFile = (path28) => new Promise((resolve16, reject) => {
+      fs19.open(path28, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs24.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
+          fs19.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
             resolve16(buffer.subarray(0, bytesRead));
-            fs24.close(fd, () => {
+            fs19.close(fd, () => {
             });
           });
         }
@@ -48925,7 +49553,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: readFileSync19 } = require_filesystem();
     var { interpreterPath } = require_elf();
@@ -48937,7 +49565,7 @@ var require_detect_libc = __commonJS({
     var safeCommand = () => {
       if (!commandOut) {
         return new Promise((resolve16) => {
-          childProcess2.exec(command, (err, out) => {
+          childProcess.exec(command, (err, out) => {
             commandOut = err ? " " : out;
             resolve16(commandOut);
           });
@@ -48948,7 +49576,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 = " ";
         }
@@ -48981,11 +49609,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path29) => {
-      if (path29) {
-        if (path29.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path28) => {
+      if (path28) {
+        if (path28.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path29.includes("/ld-linux-")) {
+        } else if (path28.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -49032,8 +49660,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile(SELF_PATH);
-        const path29 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path29);
+        const path28 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path28);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -49045,8 +49673,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = readFileSync19(SELF_PATH);
-        const path29 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path29);
+        const path28 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path28);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -50765,18 +51393,18 @@ var require_sharp = __commonJS({
       `@img/sharp-${runtimePlatform}/sharp.node`,
       "@img/sharp-wasm32/sharp.node"
     ];
-    var path29;
+    var path28;
     var sharp;
     var errors = [];
-    for (path29 of paths) {
+    for (path28 of paths) {
       try {
-        sharp = require(path29);
+        sharp = require(path28);
         break;
       } catch (err) {
         errors.push(err);
       }
     }
-    if (sharp && path29.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
+    if (sharp && path28.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);
@@ -50785,7 +51413,7 @@ var require_sharp = __commonJS({
     if (sharp) {
       module2.exports = sharp;
     } else {
-      const [isLinux2, isMacOs, isWindows2] = ["linux", "darwin", "win32"].map((os29) => runtimePlatform.startsWith(os29));
+      const [isLinux2, isMacOs, isWindows2] = ["linux", "darwin", "win32"].map((os28) => runtimePlatform.startsWith(os28));
       const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
       errors.forEach((err) => {
         if (err.code !== "MODULE_NOT_FOUND") {
@@ -50802,15 +51430,15 @@ var require_sharp = __commonJS({
           `    Requires ${expected}`
         );
       } else if (prebuiltPlatforms.includes(runtimePlatform)) {
-        const [os29, cpu] = runtimePlatform.split("-");
-        const libc = os29.endsWith("musl") ? " --libc=musl" : "";
+        const [os28, cpu] = runtimePlatform.split("-");
+        const libc = os28.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=${os29.replace("musl", "")}${libc} --cpu=${cpu} sharp`
+          `    npm install --os=${os28.replace("musl", "")}${libc} --cpu=${cpu} sharp`
         );
       } else {
         help.push(
@@ -53685,15 +54313,15 @@ var require_color = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path29 = [graph[toModel].parent, toModel];
+      const path28 = [graph[toModel].parent, toModel];
       let fn = conversions_default[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path29.unshift(graph[cur].parent);
+        path28.unshift(graph[cur].parent);
         fn = link(conversions_default[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path29;
+      fn.conversion = path28;
       return fn;
     }
     function route(fromModel) {
@@ -54310,7 +54938,7 @@ var require_channel = __commonJS({
 var require_output = __commonJS({
   "../../node_modules/sharp/lib/output.js"(exports2, module2) {
     "use strict";
-    var path29 = require("path");
+    var path28 = require("path");
     var is = require_is();
     var sharp = require_sharp();
     var formats = /* @__PURE__ */ new Map([
@@ -54341,9 +54969,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) && path29.resolve(this.options.input.file) === path29.resolve(fileOut)) {
+      } else if (is.string(this.options.input.file) && path28.resolve(this.options.input.file) === path28.resolve(fileOut)) {
         err = new Error("Cannot use same file for input and output");
-      } else if (jp2Regex.test(path29.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+      } else if (jp2Regex.test(path28.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
         err = errJp2Save();
       }
       if (err) {
@@ -56460,18 +57088,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,
@@ -56630,7 +57258,7 @@ function removeDaemonPid(ref = {}) {
 function isDaemonRunning(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync6 } = require("child_process");
+    const { execFileSync: execFileSync5 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -56640,7 +57268,7 @@ function isDaemonRunning(ref = {}) {
             req.on('error', () => process.stdout.write('0'));
             req.on('timeout', () => { req.destroy(); process.stdout.write('0'); });
         `;
-    const result = execFileSync6(process.execPath, ["-e", probe], {
+    const result = execFileSync5(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -56666,9 +57294,9 @@ function isDaemonRunning(ref = {}) {
 function isAdhdevProcess(pid) {
   try {
     if (process.platform === "win32") {
-      const { execFileSync: execFileSync6 } = require("child_process");
+      const { execFileSync: execFileSync5 } = require("child_process");
       try {
-        const psOut = execFileSync6("powershell.exe", [
+        const psOut = execFileSync5("powershell.exe", [
           "-NoProfile",
           "-NonInteractive",
           "-ExecutionPolicy",
@@ -56681,8 +57309,8 @@ function isAdhdevProcess(pid) {
         return true;
       }
     } else {
-      const { execFileSync: execFileSync6 } = require("child_process");
-      const cmdline = execFileSync6("ps", ["-o", "command=", "-p", String(pid)], {
+      const { execFileSync: execFileSync5 } = require("child_process");
+      const cmdline = execFileSync5("ps", ["-o", "command=", "-p", String(pid)], {
         encoding: "utf-8",
         timeout: 2e3,
         stdio: ["ignore", "pipe", "ignore"]
@@ -56696,7 +57324,7 @@ function isAdhdevProcess(pid) {
 function getDaemonHealthPid(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync6 } = require("child_process");
+    const { execFileSync: execFileSync5 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -56714,7 +57342,7 @@ function getDaemonHealthPid(ref = {}) {
             req.on('error', () => {});
             req.on('timeout', () => { req.destroy(); });
         `;
-    const result = execFileSync6(process.execPath, ["-e", probe], {
+    const result = execFileSync5(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -56782,7 +57410,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.44" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.45" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -58034,11 +58662,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 + "";
@@ -61576,7 +62204,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);
         });
       });
@@ -61586,7 +62214,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() {
@@ -69245,15 +69873,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path29 = [graph[toModel].parent, toModel];
+      const path28 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path29.unshift(graph[cur].parent);
+        path28.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path29;
+      fn.conversion = path28;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -69650,7 +70278,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os29 = require("os");
+    var os28 = require("os");
     var tty3 = require("tty");
     var hasFlag3 = require_has_flag();
     var { env: env3 } = process;
@@ -69698,7 +70326,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os29.release().split(".");
+        const osRelease = os28.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -69999,18 +70627,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,
@@ -70174,11 +70802,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() {
         };
@@ -70186,15 +70814,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 = {};
       }
@@ -70231,12 +70859,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;
@@ -70253,7 +70881,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);
@@ -70261,7 +70889,7 @@ var require_signal_exit = __commonJS({
             if (isWin && sig === "SIGHUP") {
               sig = "SIGINT";
             }
-            process19.kill(process19.pid, sig);
+            process13.kill(process13.pid, sig);
           }
         };
       });
@@ -70277,36 +70905,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);
@@ -72496,12 +73124,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() {
@@ -72561,8 +73189,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) {
@@ -72626,7 +73254,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);
@@ -72958,14 +73586,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();
@@ -73093,7 +73721,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") {
@@ -73137,7 +73765,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;
     }
@@ -73508,34 +74136,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);
@@ -73551,7 +74179,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") {
@@ -73566,8 +74194,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":
@@ -73615,7 +74243,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;
@@ -73644,7 +74272,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 "";
@@ -74205,14 +74833,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;
@@ -74320,7 +74948,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;
@@ -74345,7 +74973,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) {
@@ -75156,7 +75784,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)) {
@@ -75220,10 +75848,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);
@@ -75233,7 +75861,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);
@@ -75245,7 +75873,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;
@@ -75321,7 +75949,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]);
@@ -75334,7 +75962,7 @@ var require_BufferList = __commonJS({
         if (typeof buf === "number") {
           buf = buf.toString();
         }
-        this._appendBuffer(Buffer3.from(buf));
+        this._appendBuffer(Buffer2.from(buf));
       }
       return this;
     };
@@ -75350,15 +75978,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)) {
@@ -82674,10 +83302,10 @@ var require_lib2 = __commonJS({
     exports2.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve16, reject) => {
       let fd;
-      const fs24 = (0, node_1.default)();
+      const fs19 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs24.closeSync(fd);
+          fs19.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -82689,9 +83317,9 @@ var require_lib2 = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs24.openSync(filepath, "r");
+        fd = fs19.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs24.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs19.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -82703,22 +83331,22 @@ var require_lib2 = __commonJS({
         });
         return;
       }
-      fs24.readFile(filepath, handler);
+      fs19.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs24 = (0, node_1.default)();
+      const fs19 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs24.openSync(filepath, "r");
+        const fd = fs19.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs24.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs19.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs24.closeSync(fd);
+        fs19.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs24.readFileSync(filepath));
+      return (0, exports2.detect)(fs19.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -82735,7 +83363,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) {
@@ -82744,12 +83372,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") {
@@ -82758,7 +83386,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) {
@@ -82769,7 +83397,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") {
@@ -82864,7 +83492,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 },
@@ -82888,7 +83516,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;
         }
@@ -82901,8 +83529,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);
     };
@@ -82913,7 +83541,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() {
     };
@@ -82925,15 +83553,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);
@@ -83029,13 +83657,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);
       }
     };
   }
@@ -83045,7 +83673,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;
@@ -83063,8 +83691,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) {
@@ -83100,7 +83728,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 {
@@ -83120,7 +83748,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;
@@ -83276,7 +83904,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() {
     }
@@ -83286,7 +83914,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];
@@ -83303,7 +83931,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) {
@@ -83419,7 +84047,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) {
@@ -83433,7 +84061,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)));
     };
@@ -83471,7 +84099,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--;
@@ -83489,7 +84117,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;
@@ -83498,7 +84126,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 = "";
@@ -83514,14 +84142,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);
@@ -83560,7 +84188,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) {
@@ -83597,7 +84225,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--;
@@ -83615,7 +84243,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;
@@ -83624,7 +84252,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 = "";
@@ -83637,7 +84265,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) {
@@ -83653,8 +84281,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;
       }
@@ -83666,7 +84294,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)];
       }
@@ -83679,7 +84307,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++) {
@@ -84307,7 +84935,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;
@@ -84543,7 +85171,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;
@@ -84647,7 +85275,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];
@@ -84678,7 +85306,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;
@@ -86287,7 +86915,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) {
@@ -86327,7 +86955,7 @@ var require_streams = __commonJS({
           chunks.push(chunk);
         });
         this.on("end", function() {
-          cb(null, Buffer3.concat(chunks));
+          cb(null, Buffer2.concat(chunks));
         });
         return this;
       };
@@ -86341,7 +86969,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 {
@@ -86384,7 +87012,7 @@ var require_streams = __commonJS({
 var require_lib3 = __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;
@@ -86395,7 +87023,7 @@ var require_lib3 = __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") {
@@ -86403,7 +87031,7 @@ var require_lib3 = __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);
@@ -87123,9 +87751,9 @@ var init_prompt = __esm({
     init_utils();
     init_baseUI();
     _ = {
-      set: (obj, path29 = "", value) => {
+      set: (obj, path28 = "", value) => {
         let pointer = obj;
-        path29.split(".").forEach((key, index, arr) => {
+        path28.split(".").forEach((key, index, arr) => {
           if (key === "__proto__" || key === "constructor") return;
           if (index === arr.length - 1) {
             pointer[key] = value;
@@ -87135,8 +87763,8 @@ var init_prompt = __esm({
           pointer = pointer[key];
         });
       },
-      get: (obj, path29 = "", defaultValue) => {
-        const travel = (regexp) => String.prototype.split.call(path29, regexp).filter(Boolean).reduce(
+      get: (obj, path28 = "", defaultValue) => {
+        const travel = (regexp) => String.prototype.split.call(path28, regexp).filter(Boolean).reduce(
           // @ts-expect-error implicit any on res[key]
           (res, key) => res !== null && res !== void 0 ? res[key] : res,
           obj
@@ -87452,7 +88080,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);
@@ -87545,15 +88173,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;
             }
@@ -87562,12 +88190,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)) {
@@ -88432,523 +89060,6 @@ init_daemon_p2p2();
 init_source2();
 init_lib();
 init_ora();
-
-// ../../node_modules/open/index.js
-var import_node_process15 = __toESM(require("process"), 1);
-var import_node_buffer = require("buffer");
-var import_node_path3 = __toESM(require("path"), 1);
-var import_node_url = require("url");
-var import_node_util5 = require("util");
-var import_node_child_process5 = __toESM(require("child_process"), 1);
-var import_promises5 = __toESM(require("fs/promises"), 1);
-
-// ../../node_modules/wsl-utils/index.js
-var import_node_process11 = __toESM(require("process"), 1);
-var import_promises4 = __toESM(require("fs/promises"), 1);
-
-// ../../node_modules/is-wsl/index.js
-var import_node_process10 = __toESM(require("process"), 1);
-var import_node_os5 = __toESM(require("os"), 1);
-var import_node_fs5 = __toESM(require("fs"), 1);
-
-// ../../node_modules/is-inside-container/index.js
-var import_node_fs4 = __toESM(require("fs"), 1);
-
-// ../../node_modules/is-docker/index.js
-var import_node_fs3 = __toESM(require("fs"), 1);
-var isDockerCached;
-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;
-}
-
-// ../../node_modules/is-inside-container/index.js
-var cachedResult;
-var hasContainerEnv = () => {
-  try {
-    import_node_fs4.default.statSync("/run/.containerenv");
-    return true;
-  } catch {
-    return false;
-  }
-};
-function isInsideContainer() {
-  if (cachedResult === void 0) {
-    cachedResult = hasContainerEnv() || isDocker();
-  }
-  return cachedResult;
-}
-
-// ../../node_modules/is-wsl/index.js
-var 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;
-};
-var is_wsl_default = import_node_process10.default.env.__IS_WSL_TEST__ ? isWsl : isWsl();
-
-// ../../node_modules/wsl-utils/index.js
-var 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;
-  };
-})();
-var powerShellPathFromWsl = async () => {
-  const mountPoint = await wslDrivesMountPoint();
-  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
-};
-var 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;
-}
-
-// ../../node_modules/default-browser/index.js
-var import_node_util4 = require("util");
-var import_node_process14 = __toESM(require("process"), 1);
-var import_node_child_process4 = require("child_process");
-
-// ../../node_modules/default-browser-id/index.js
-var import_node_util = require("util");
-var import_node_process12 = __toESM(require("process"), 1);
-var import_node_child_process = require("child_process");
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
-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;
-}
-
-// ../../node_modules/run-applescript/index.js
-var import_node_process13 = __toESM(require("process"), 1);
-var import_node_util2 = require("util");
-var import_node_child_process2 = require("child_process");
-var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
-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();
-}
-
-// ../../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")`);
-}
-
-// ../../node_modules/default-browser/windows.js
-var import_node_util3 = require("util");
-var import_node_child_process3 = require("child_process");
-var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
-var 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" }
-};
-var _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
-var UnknownBrowserError = class extends Error {
-};
-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 };
-}
-
-// ../../node_modules/default-browser/index.js
-var execFileAsync4 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
-var titleize = (string4) => string4.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
-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");
-}
-
-// ../../node_modules/open/index.js
-var import_meta = {};
-var execFile5 = (0, import_node_util5.promisify)(import_node_child_process5.default.execFile);
-var __dirname2 = import_node_path3.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
-var localXdgOpenPath = import_node_path3.default.join(__dirname2, "xdg-open");
-var { platform: platform12, arch: arch3 } = import_node_process15.default;
-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] } : {};
-}
-var pTryEach = async (array2, mapper) => {
-  let latestError;
-  for (const item of array2) {
-    try {
-      return await mapper(item);
-    } catch (error48) {
-      latestError = error48;
-    }
-  }
-  throw latestError;
-};
-var 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 (platform12 === "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 (platform12 === "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 ?? (platform12 === "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 (platform12 === "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((resolve16, reject) => {
-      subprocess.once("error", reject);
-      subprocess.once("close", (exitCode) => {
-        if (!options.allowNonzeroExitCode && exitCode > 0) {
-          reject(new Error(`Exited with code ${exitCode}`));
-          return;
-        }
-        resolve16(subprocess);
-      });
-    });
-  }
-  subprocess.unref();
-  return subprocess;
-};
-var open2 = (target, options) => {
-  if (typeof target !== "string") {
-    throw new TypeError("Expected a `target`");
-  }
-  return baseOpen({
-    ...options,
-    target
-  });
-};
-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({ [platform12]: platformBinary }, { wsl }) {
-  if (wsl && is_wsl_default) {
-    return detectArchBinary(wsl);
-  }
-  if (!platformBinary) {
-    throw new Error(`${platform12} is not supported`);
-  }
-  return detectArchBinary(platformBinary);
-}
-var 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");
-var open_default = open2;
-
-// src/wizard.ts
 init_src();
 init_version();
 var SERVER_URL = process.env.ADHDEV_SERVER_URL || "https://api.adhf.dev";
@@ -88959,6 +89070,10 @@ ${source_default2.cyan("\u2551")}  ${source_default2.gray("Agent Dashboard Hub f
 ${source_default2.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
 `;
 var DIVIDER = source_default2.gray("\u2500".repeat(44));
+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());
@@ -89008,9 +89123,9 @@ async function runWizard(options = {}) {
 }
 async function checkForUpdate() {
   try {
-    const { execFileSync: execFileSync6 } = await import("child_process");
+    const { execFileSync: execFileSync5 } = await import("child_process");
     const currentVersion = resolvePackageVersion();
-    const latestVersion = readLatestPublishedCliVersion(execFileSync6);
+    const latestVersion = readLatestPublishedCliVersion(execFileSync5);
     if (!latestVersion) return;
     if (!currentVersion || !latestVersion || currentVersion === latestVersion) return;
     console.log(source_default2.yellow(`  Update available: ${currentVersion} \u2192 ${latestVersion}`));
@@ -89027,7 +89142,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" });
-      execFileSync6(installCommand.command, installCommand.args, {
+      execFileSync5(installCommand.command, installCommand.args, {
         encoding: "utf-8",
         timeout: 6e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -89111,15 +89226,15 @@ async function loginFlow() {
   let verificationUrl;
   try {
     const config2 = loadConfig();
-    const os29 = await import("os");
+    const os28 = 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: os29.hostname(),
-        platform: os29.platform(),
-        arch: os29.arch()
+        hostname: os28.hostname(),
+        platform: os28.platform(),
+        arch: os28.arch()
       })
     });
     if (!res.ok) {
@@ -89143,7 +89258,7 @@ async function loginFlow() {
   console.log(source_default2.gray(`  Opening: ${verificationUrl}`));
   console.log();
   try {
-    await open_default(verificationUrl);
+    await openBrowser(verificationUrl);
     console.log(source_default2.green("  \u2713 Browser opened \u2014 please sign in and approve"));
   } catch {
     console.log(source_default2.yellow(`  \u26A0 Could not open browser. Visit: ${verificationUrl}`));
@@ -89224,10 +89339,10 @@ async function startDaemonFlow() {
     const { execSync: execSync7 } = await import("child_process");
     const { getCurrentDaemonLogPath: getCurrentDaemonLogPath2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const logPath = getCurrentDaemonLogPath2();
-    const os29 = await import("os");
-    const platform13 = os29.platform();
+    const os28 = await import("os");
+    const platform12 = os28.platform();
     try {
-      if (platform13 === "win32") {
+      if (platform12 === "win32") {
         execSync7("start /B adhdev daemon >NUL 2>&1", {
           timeout: 3e3,
           stdio: "ignore",