app-ai-solution-exp 0.1.2

package/out/main/index.js

@@ -0,0 +1,1631 @@
+"use strict";
+const electron = require("electron");
+const path = require("path");
+const child_process = require("child_process");
+const os = require("os");
+const fs = require("fs");
+const nodePty = require("node-pty");
+const crypto = require("crypto");
+const keytar = require("keytar");
+let mainWindow = null;
+function createMainWindow() {
+  mainWindow = new electron.BrowserWindow({
+    width: 1200,
+    height: 800,
+    minWidth: 1024,
+    minHeight: 600,
+    show: false,
+    // mostrar apenas quando pronto (evita flash)
+    titleBarStyle: process.platform === "darwin" ? "hiddenInset" : "hidden",
+    backgroundColor: "#0e0e10",
+    // Zinc Dark background — evita flash branco
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      contextIsolation: true,
+      // ✅ obrigatório — isola preload do renderer
+      nodeIntegration: false,
+      // ✅ obrigatório — renderer não acessa Node.js
+      sandbox: true,
+      // ✅ obrigatório — sandboxing do renderer
+      webSecurity: true,
+      allowRunningInsecureContent: false
+    }
+  });
+  mainWindow.webContents.on("before-input-event", (_event, input) => {
+    if (!input.control && !input.meta) return;
+    const zoom = mainWindow.webContents.getZoomFactor();
+    if (input.key === "=" || input.key === "+") {
+      mainWindow.webContents.setZoomFactor(Math.min(zoom + 0.1, 3));
+    } else if (input.key === "-") {
+      mainWindow.webContents.setZoomFactor(Math.max(zoom - 0.1, 0.5));
+    } else if (input.key === "0") {
+      mainWindow.webContents.setZoomFactor(1);
+    }
+  });
+  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+    electron.shell.openExternal(url);
+    return { action: "deny" };
+  });
+  mainWindow.once("ready-to-show", () => {
+    mainWindow?.show();
+  });
+  mainWindow.on("closed", () => {
+    mainWindow = null;
+  });
+  mainWindow.on("maximize", () => {
+    mainWindow?.webContents.send("window:maximized", true);
+  });
+  mainWindow.on("unmaximize", () => {
+    mainWindow?.webContents.send("window:maximized", false);
+  });
+  if (process.env["ELECTRON_RENDERER_URL"]) {
+    mainWindow.loadURL(process.env["ELECTRON_RENDERER_URL"]);
+  } else {
+    mainWindow.loadFile(path.join(__dirname, "../renderer/index.html"));
+  }
+  return mainWindow;
+}
+function getMainWindow() {
+  return mainWindow;
+}
+function getCmRoot() {
+  return path.join(os.homedir(), ".cm");
+}
+function getProfileDir(profileId) {
+  return path.join(getCmRoot(), "profiles", profileId);
+}
+function getHistoryDir(profileId, projectName) {
+  return path.join(getCmRoot(), "history", profileId, projectName);
+}
+function getClaudeConfigDir() {
+  return path.join(os.homedir(), ".claude");
+}
+function getAgentsDir() {
+  return path.join(getClaudeConfigDir(), "agents");
+}
+function getGlobalClaudeMdPath() {
+  return path.join(getClaudeConfigDir(), "CLAUDE.md");
+}
+function getClaudeHistoryJsonlPath() {
+  return path.join(getClaudeConfigDir(), "history.jsonl");
+}
+function isWindows() {
+  return process.platform === "win32";
+}
+function whereExe(name) {
+  try {
+    const result = child_process.execSync(`where.exe ${name}`, { encoding: "utf8", timeout: 3e3 });
+    const first = result.trim().split(/\r?\n/)[0].trim();
+    return first && fs.existsSync(first) ? first : null;
+  } catch {
+    return null;
+  }
+}
+function getClaudeSpawnConfig() {
+  if (!isWindows()) {
+    return { file: "claude", args: [] };
+  }
+  const systemRoot = process.env.SystemRoot ?? "C:\\Windows";
+  const cmdExe = path.join(systemRoot, "System32", "cmd.exe");
+  try {
+    const claudeCmdPath = whereExe("claude");
+    if (claudeCmdPath) {
+      const npmDir = path.dirname(claudeCmdPath);
+      const cliJsPath = path.join(
+        npmDir,
+        "node_modules",
+        "@anthropic-ai",
+        "claude-code",
+        "cli.js"
+      );
+      if (fs.existsSync(cliJsPath)) {
+        const nodePath = whereExe("node");
+        if (nodePath) {
+          return { file: nodePath, args: [cliJsPath] };
+        }
+      }
+      return { file: cmdExe, args: ["/c", claudeCmdPath] };
+    }
+  } catch {
+  }
+  return { file: cmdExe, args: ["/k", "claude"] };
+}
+const SUMMARY_TIMEOUT_MS = 3e4;
+function collectGitData(projectPath) {
+  const run = (cmd) => {
+    try {
+      return child_process.execSync(cmd, { cwd: projectPath, encoding: "utf8", timeout: 5e3 }).trim();
+    } catch {
+      return "";
+    }
+  };
+  return {
+    log: run("git log --oneline -8"),
+    diffStat: run("git diff --stat HEAD"),
+    status: run("git status --short")
+  };
+}
+function buildPrompt(devNote, projectName, git) {
+  const sections = [
+    `Gere um resumo estruturado de sessão de desenvolvimento para o projeto "${projectName}".`,
+    "",
+    "Use exatamente este formato markdown:",
+    "## O que foi feito",
+    "## Arquivos modificados",
+    "## Decisões tomadas",
+    "## Pendências",
+    "## Próximos passos",
+    ""
+  ];
+  if (devNote.trim()) {
+    sections.push("### Nota do desenvolvedor", devNote.trim(), "");
+  }
+  if (git.log) {
+    sections.push("### Git log (últimas commits)", "```", git.log, "```", "");
+  }
+  if (git.diffStat) {
+    sections.push("### Arquivos alterados (git diff --stat HEAD)", "```", git.diffStat, "```", "");
+  }
+  if (git.status) {
+    sections.push("### Status atual (git status --short)", "```", git.status, "```", "");
+  }
+  sections.push("Gere o resumo em português do Brasil. Seja conciso e direto ao ponto.");
+  return sections.join("\n");
+}
+function buildFallback(devNote, projectName, git) {
+  const lines = [
+    `# Resumo de sessão — ${projectName}`,
+    `_Gerado automaticamente (sem IA)_`,
+    ""
+  ];
+  if (devNote.trim()) lines.push("## Nota do desenvolvedor", devNote.trim(), "");
+  if (git.log) lines.push("## Git log", "```", git.log, "```", "");
+  if (git.diffStat) lines.push("## Arquivos alterados", "```", git.diffStat, "```", "");
+  if (git.status) lines.push("## Status", "```", git.status, "```", "");
+  if (!devNote.trim() && !git.log && !git.diffStat && !git.status) {
+    lines.push("_Nenhuma informação disponível para esta sessão._");
+  }
+  return lines.join("\n");
+}
+function generateSummary(payload) {
+  const { profileId, projectName, projectPath, devNote } = payload;
+  const profileDir = getProfileDir(profileId);
+  const git = collectGitData(projectPath);
+  const prompt = buildPrompt(devNote, projectName, git);
+  return new Promise((resolve) => {
+    const { file, args } = getClaudeSpawnConfig();
+    let spawnFile;
+    let spawnArgs;
+    if (args.length > 0 && args[0] === "/c") {
+      spawnFile = file;
+      spawnArgs = [...args, "--print", prompt];
+    } else if (args.length > 0 && args[0] === "/k") {
+      spawnFile = file;
+      spawnArgs = ["/c", "claude", "--print", prompt];
+    } else if (args.length > 0) {
+      spawnFile = file;
+      spawnArgs = [...args, "--print", prompt];
+    } else {
+      spawnFile = file;
+      spawnArgs = ["--print", prompt];
+    }
+    const env = { ...process.env, CLAUDE_CONFIG_DIR: profileDir, NODE_ENV: void 0 };
+    let output = "";
+    let timedOut = false;
+    const child = child_process.spawn(spawnFile, spawnArgs, { env, shell: false });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+      resolve({ success: false, content: buildFallback(devNote, projectName, git), isFallback: true });
+    }, SUMMARY_TIMEOUT_MS);
+    child.stdout.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (timedOut) return;
+      const trimmed = output.trim();
+      if (code === 0 && trimmed.length > 50) {
+        resolve({ success: true, content: trimmed, isFallback: false });
+      } else {
+        resolve({ success: false, content: buildFallback(devNote, projectName, git), isFallback: true });
+      }
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      if (timedOut) return;
+      resolve({ success: false, content: buildFallback(devNote, projectName, git), isFallback: true });
+    });
+  });
+}
+function checkClaudePath() {
+  const command = process.platform === "win32" ? "where claude" : "which claude";
+  try {
+    const output = child_process.execSync(command, { encoding: "utf8", timeout: 5e3 }).trim();
+    const claudePath = output.split("\n")[0].trim();
+    if (claudePath) {
+      return { found: true, path: claudePath };
+    }
+    return { found: false, path: null };
+  } catch {
+    return { found: false, path: null };
+  }
+}
+function registerClaudeCheckHandlers() {
+  electron.ipcMain.handle("claude:checkPath", () => {
+    return checkClaudePath();
+  });
+}
+async function createProfileDirectory(profileId) {
+  const dir = getProfileDir(profileId);
+  await fs.promises.mkdir(dir, { recursive: true });
+}
+function profileDirectoryExists(profileId) {
+  return fs.existsSync(getProfileDir(profileId));
+}
+function profileHasCredentials(profileId) {
+  const credentialsPath = path.join(getProfileDir(profileId), ".credentials.json");
+  return fs.existsSync(credentialsPath);
+}
+const MARKER_START = "<!-- CM:CONTEXT:START -->";
+const MARKER_END = "<!-- CM:CONTEXT:END -->";
+function injectContext(projectClaudeMdPath, summaryContent) {
+  const block = `${MARKER_START}
+${summaryContent}
+${MARKER_END}
+
+`;
+  let existing = "";
+  const fileExists = fs.existsSync(projectClaudeMdPath);
+  if (fileExists) {
+    existing = fs.readFileSync(projectClaudeMdPath, "utf8");
+    fs.writeFileSync(`${projectClaudeMdPath}.cm-bkp`, existing, "utf8");
+  }
+  const stripped = removeContextBlock(existing);
+  const result = block + stripped;
+  fs.mkdirSync(path.dirname(projectClaudeMdPath), { recursive: true });
+  fs.writeFileSync(projectClaudeMdPath, result, "utf8");
+}
+function cleanContext(projectClaudeMdPath) {
+  if (!fs.existsSync(projectClaudeMdPath)) return;
+  const content = fs.readFileSync(projectClaudeMdPath, "utf8");
+  const stripped = removeContextBlock(content);
+  if (stripped.trim() === "") {
+    fs.unlinkSync(projectClaudeMdPath);
+  } else {
+    fs.writeFileSync(projectClaudeMdPath, stripped, "utf8");
+  }
+  const backupPath = `${projectClaudeMdPath}.cm-bkp`;
+  if (fs.existsSync(backupPath)) {
+    try {
+      fs.unlinkSync(backupPath);
+    } catch {
+    }
+  }
+}
+function hasContextMarkers(projectClaudeMdPath) {
+  if (!fs.existsSync(projectClaudeMdPath)) return false;
+  try {
+    const content = fs.readFileSync(projectClaudeMdPath, "utf8");
+    return content.includes(MARKER_START);
+  } catch {
+    return false;
+  }
+}
+function removeContextBlock(content) {
+  const startIdx = content.indexOf(MARKER_START);
+  const endIdx = content.indexOf(MARKER_END);
+  if (startIdx === -1 || endIdx === -1) return content;
+  const before = content.slice(0, startIdx);
+  const after = content.slice(endIdx + MARKER_END.length);
+  return (before + after).replace(/^\n\n/, "\n").trimStart();
+}
+function listProjects(profileId) {
+  const historyRoot = path.join(getCmRoot(), "history", profileId);
+  if (!fs.existsSync(historyRoot)) return [];
+  return fs.readdirSync(historyRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+}
+function listSummaries(profileId, projectName) {
+  const dir = getHistoryDir(profileId, projectName);
+  if (!fs.existsSync(dir)) return [];
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".md")).sort().reverse();
+  return files.map((file) => {
+    const filePath = path.join(dir, file);
+    let preview = "";
+    try {
+      const content = fs.readFileSync(filePath, "utf8");
+      preview = content.slice(0, 200);
+    } catch {
+    }
+    return {
+      filePath,
+      profileId,
+      projectName,
+      date: file.replace(".md", ""),
+      preview
+    };
+  });
+}
+function readSummary(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function saveSummary(profileId, projectName, content) {
+  const dir = getHistoryDir(profileId, projectName);
+  fs.mkdirSync(dir, { recursive: true });
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const timestamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(now.getHours())}-${pad(now.getMinutes())}`;
+  const filePath = path.join(dir, `${timestamp}.md`);
+  fs.writeFileSync(filePath, content, "utf8");
+  return filePath;
+}
+function readOrphanContent(jsonlPath, maxLines = 50) {
+  try {
+    const raw = fs.readFileSync(jsonlPath, "utf8");
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const last = lines.slice(-maxLines);
+    const messages = [];
+    for (const line of last) {
+      try {
+        const obj = JSON.parse(line);
+        const role = typeof obj.role === "string" ? obj.role : "unknown";
+        const content = typeof obj.content === "string" ? obj.content : JSON.stringify(obj.content ?? "");
+        const truncated = content.length > 500 ? content.slice(0, 500) + "…" : content;
+        messages.push(`[${role}] ${truncated}`);
+      } catch {
+        messages.push(line.slice(0, 200));
+      }
+    }
+    const truncationNotice = lines.length > maxLines ? `
+
+_[Exibindo as últimas ${maxLines} de ${lines.length} mensagens]_
+` : "";
+    return `${truncationNotice}${messages.join("\n\n")}`;
+  } catch {
+    return null;
+  }
+}
+function detectOrphanSessions(profileId) {
+  const projectsRoot = path.join(getProfileDir(profileId), "projects");
+  if (!fs.existsSync(projectsRoot)) return [];
+  const orphans = [];
+  let projectDirs;
+  try {
+    projectDirs = fs.readdirSync(projectsRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  for (const projectName of projectDirs) {
+    const projectDir = path.join(projectsRoot, projectName);
+    let jsonlFiles;
+    try {
+      jsonlFiles = fs.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    const historyDir = getHistoryDir(profileId, projectName);
+    const existingSummaries = fs.existsSync(historyDir) ? new Set(fs.readdirSync(historyDir).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""))) : /* @__PURE__ */ new Set();
+    for (const jsonlFile of jsonlFiles) {
+      const datePart = jsonlFile.replace(".jsonl", "");
+      if (!existingSummaries.has(datePart)) {
+        orphans.push({
+          profileId,
+          projectName,
+          jsonlPath: path.join(projectDir, jsonlFile),
+          sessionDate: datePart
+        });
+      }
+    }
+  }
+  return orphans;
+}
+function listNativeSessions() {
+  const historyPath = getClaudeHistoryJsonlPath();
+  if (!fs.existsSync(historyPath)) return [];
+  let raw;
+  try {
+    raw = fs.readFileSync(historyPath, "utf8");
+  } catch {
+    return [];
+  }
+  const sessionsMap = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n").filter((l) => l.trim())) {
+    try {
+      const obj = JSON.parse(line);
+      const sessionId = typeof obj.sessionId === "string" ? obj.sessionId : null;
+      const project = typeof obj.project === "string" ? obj.project : null;
+      const display = typeof obj.display === "string" ? obj.display : "";
+      const timestamp = typeof obj.timestamp === "number" ? obj.timestamp : 0;
+      if (!sessionId || !project) continue;
+      if (!sessionsMap.has(sessionId)) {
+        sessionsMap.set(sessionId, { projectPath: project, messages: [] });
+      }
+      sessionsMap.get(sessionId).messages.push({ display, timestamp });
+    } catch {
+      continue;
+    }
+  }
+  const result = [];
+  for (const [sessionId, data] of sessionsMap) {
+    const projectName = data.projectPath.split(/[\\/]/).pop() ?? data.projectPath;
+    const sorted = data.messages.slice().sort((a, b) => a.timestamp - b.timestamp);
+    const last = sorted[sorted.length - 1];
+    result.push({
+      sessionId,
+      projectPath: data.projectPath,
+      projectName,
+      firstMessage: (sorted[0]?.display ?? "").slice(0, 200),
+      messageCount: sorted.length,
+      lastMessageAt: new Date(last?.timestamp ?? 0).toISOString(),
+      messages: sorted
+    });
+  }
+  return result.sort((a, b) => b.lastMessageAt.localeCompare(a.lastMessageAt));
+}
+function formatToolAction(tool) {
+  const name = typeof tool.name === "string" ? tool.name : "";
+  const input = tool.input;
+  const basename = (p) => typeof p === "string" ? p.split(/[\\/]/).pop() ?? p : "";
+  switch (name) {
+    case "Read":
+      return `Read → ${basename(input?.file_path)}`;
+    case "Write":
+      return `Write → ${basename(input?.file_path)}`;
+    case "Edit":
+      return `Edit → ${basename(input?.file_path)}`;
+    case "Bash": {
+      const desc = typeof input?.description === "string" ? input.description : "";
+      const cmd = typeof input?.command === "string" ? input.command.slice(0, 80) : "";
+      return `Bash → ${desc || cmd}`;
+    }
+    case "Glob":
+      return `Glob → ${typeof input?.pattern === "string" ? input.pattern : ""}`;
+    case "Task": {
+      const subagent = typeof input?.subagent_type === "string" ? input.subagent_type : "";
+      return `Task → ${subagent}`;
+    }
+    case "TaskOutput":
+      return `TaskOutput → aguardou resultado`;
+    default:
+      return name ? `${name}` : null;
+  }
+}
+const SYSTEM_MESSAGE_PREFIXES = [
+  "<task-notification>",
+  "<local-command-caveat>",
+  "<command-name>",
+  "<local-command-stdout>"
+];
+function extractUserAnswers(content) {
+  const PREFIX = "User has answered your questions: ";
+  if (!content.startsWith(PREFIX)) return null;
+  let text = content.slice(PREFIX.length);
+  for (const suffix of [". You can now continue", " user notes:", " selected markdown:"]) {
+    const idx = text.indexOf(suffix);
+    if (idx !== -1) text = text.slice(0, idx);
+  }
+  const answers = [];
+  const regex = /"[^"]*"="([^"]*)"/g;
+  let m;
+  while ((m = regex.exec(text)) !== null) {
+    if (m[1].trim()) answers.push(m[1].trim());
+  }
+  if (answers.length > 0) return answers.join("\n");
+  return text.trim() || null;
+}
+function emptyStats() {
+  return {
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheRead: 0,
+    totalCacheCreate: 0,
+    totalMessages: 0,
+    totalToolCalls: 0,
+    durationMs: 0,
+    firstTimestamp: "",
+    lastTimestamp: "",
+    compactionCount: 0,
+    compactionTokensIn: 0,
+    compactionTokensOut: 0
+  };
+}
+function readNativeSessionConversation(sessionId) {
+  const projectsDir = path.join(getClaudeConfigDir(), "projects");
+  if (!fs.existsSync(projectsDir)) return { messages: [], stats: emptyStats() };
+  let jsonlPath = null;
+  try {
+    for (const proj of fs.readdirSync(projectsDir)) {
+      const candidate = path.join(projectsDir, proj, `${sessionId}.jsonl`);
+      if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+        jsonlPath = candidate;
+        break;
+      }
+    }
+  } catch {
+    return { messages: [], stats: emptyStats() };
+  }
+  if (!jsonlPath) return { messages: [], stats: emptyStats() };
+  let raw;
+  try {
+    raw = fs.readFileSync(jsonlPath, "utf8");
+  } catch {
+    return { messages: [], stats: emptyStats() };
+  }
+  const result = [];
+  let lastToolEntryIdx = -1;
+  let lastToolTimestamp = null;
+  for (const line of raw.split("\n").filter((l) => l.trim())) {
+    try {
+      const obj = JSON.parse(line);
+      if (obj.isSidechain === true) continue;
+      if (obj.type !== "user" && obj.type !== "assistant") continue;
+      const msg = obj.message;
+      if (!msg) continue;
+      const timestamp = typeof obj.timestamp === "string" ? obj.timestamp : "";
+      if (obj.type === "user") {
+        if (typeof msg.content === "string") {
+          const c = msg.content.trim();
+          if (!c) continue;
+          if (SYSTEM_MESSAGE_PREFIXES.some((p) => c.startsWith(p))) continue;
+          result.push({ role: "user", content: c, timestamp });
+        } else if (Array.isArray(msg.content)) {
+          const items = msg.content;
+          const hasToolResult = items.some((item) => item.type === "tool_result");
+          if (hasToolResult && lastToolEntryIdx >= 0 && lastToolTimestamp) {
+            const startMs = new Date(lastToolTimestamp).getTime();
+            const endMs = new Date(timestamp).getTime();
+            if (!isNaN(startMs) && !isNaN(endMs) && endMs >= startMs) {
+              result[lastToolEntryIdx].durationMs = endMs - startMs;
+            }
+            lastToolEntryIdx = -1;
+            lastToolTimestamp = null;
+          }
+          for (const item of items) {
+            if (item.type === "tool_result" && typeof item.content === "string") {
+              const answers = extractUserAnswers(item.content);
+              if (answers) {
+                result.push({ role: "user", content: answers, timestamp });
+                break;
+              }
+            }
+          }
+        }
+      } else {
+        if (!Array.isArray(msg.content)) continue;
+        const items = msg.content;
+        const usageRaw = msg.usage;
+        const tokens = usageRaw ? {
+          input: typeof usageRaw.input_tokens === "number" ? usageRaw.input_tokens : 0,
+          output: typeof usageRaw.output_tokens === "number" ? usageRaw.output_tokens : 0,
+          cacheRead: typeof usageRaw.cache_read_input_tokens === "number" ? usageRaw.cache_read_input_tokens : 0,
+          cacheCreate: typeof usageRaw.cache_creation_input_tokens === "number" ? usageRaw.cache_creation_input_tokens : 0
+        } : void 0;
+        const parts = [];
+        const text = items.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("\n").trim();
+        if (text) parts.push(text);
+        const askTool = items.find((c) => c.type === "tool_use" && c.name === "AskUserQuestion");
+        if (askTool) {
+          const input = askTool.input;
+          const questions = Array.isArray(input.questions) ? input.questions : [];
+          const qLines = questions.filter((q) => typeof q.question === "string").map((q, i) => `${i + 1}. ${q.question}`);
+          if (qLines.length > 0) {
+            parts.push(`Perguntas:
+${qLines.join("\n")}`);
+          }
+        }
+        const combined = parts.join("\n\n").trim();
+        if (combined) {
+          result.push({ role: "assistant", content: combined, timestamp, tokens });
+        }
+        const toolActions = items.filter((c) => c.type === "tool_use" && c.name !== "AskUserQuestion").map((c) => formatToolAction(c)).filter((line2) => line2 !== null && line2.trim() !== "");
+        if (toolActions.length > 0) {
+          result.push({ role: "assistant", content: toolActions.join("\n"), timestamp, kind: "tool" });
+          lastToolEntryIdx = result.length - 1;
+          lastToolTimestamp = timestamp;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  result.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  const stats = emptyStats();
+  for (const msg of result) {
+    if (msg.tokens) {
+      stats.totalInputTokens += msg.tokens.input;
+      stats.totalOutputTokens += msg.tokens.output;
+      stats.totalCacheRead += msg.tokens.cacheRead;
+      stats.totalCacheCreate += msg.tokens.cacheCreate;
+    }
+    if (msg.kind === "tool") stats.totalToolCalls++;
+    else stats.totalMessages++;
+  }
+  const timestamps = result.map((m) => m.timestamp).filter(Boolean);
+  if (timestamps.length >= 2) {
+    const first = new Date(timestamps[0]).getTime();
+    const last = new Date(timestamps[timestamps.length - 1]).getTime();
+    stats.durationMs = Math.max(0, last - first);
+    stats.firstTimestamp = timestamps[0];
+    stats.lastTimestamp = timestamps[timestamps.length - 1];
+  }
+  const jsonlDir = path.dirname(jsonlPath);
+  let compactionFiles;
+  try {
+    compactionFiles = fs.readdirSync(jsonlDir).filter((f) => typeof f === "string" && f.startsWith("agent-acompact-") && f.endsWith(".jsonl"));
+  } catch {
+    compactionFiles = [];
+  }
+  for (const compFile of compactionFiles) {
+    try {
+      const compRaw = fs.readFileSync(path.join(jsonlDir, compFile), "utf8");
+      for (const line of compRaw.split("\n").filter((l) => l.trim())) {
+        try {
+          const obj = JSON.parse(line);
+          if (obj.type !== "assistant") continue;
+          if (obj.sessionId !== sessionId) continue;
+          const msg = obj.message;
+          if (!msg?.usage) continue;
+          const usage = msg.usage;
+          stats.compactionTokensIn += typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : 0;
+          stats.compactionTokensOut += typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : 0;
+          stats.compactionCount++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return { messages: result, stats };
+}
+function aggregateTokens() {
+  const profilesRoot = path.join(getCmRoot(), "profiles");
+  if (!fs.existsSync(profilesRoot)) return [];
+  const entries = [];
+  let profileDirs;
+  try {
+    profileDirs = fs.readdirSync(profilesRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  for (const profileId of profileDirs) {
+    const projectsRoot = path.join(profilesRoot, profileId, "projects");
+    if (!fs.existsSync(projectsRoot)) continue;
+    let projectDirs;
+    try {
+      projectDirs = fs.readdirSync(projectsRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    } catch {
+      continue;
+    }
+    for (const projectName of projectDirs) {
+      const projectDir = path.join(projectsRoot, projectName);
+      let jsonlFiles;
+      try {
+        jsonlFiles = fs.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl"));
+      } catch {
+        continue;
+      }
+      for (const jsonlFile of jsonlFiles) {
+        const datePart = jsonlFile.replace(".jsonl", "").split("_")[0] ?? jsonlFile.replace(".jsonl", "");
+        entries.push(parseJsonlUsage(path.join(projectDir, jsonlFile), profileId, projectName, datePart));
+      }
+    }
+  }
+  return entries;
+}
+function parseJsonlUsage(filePath, profileId, projectName, date) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let model = null;
+  let unavailable = true;
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const lines = raw.split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      try {
+        const obj = JSON.parse(line);
+        const msg = obj.message;
+        if (msg?.usage && typeof msg.usage === "object") {
+          const usage = msg.usage;
+          inputTokens += typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+          outputTokens += typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+          if (typeof msg.model === "string" && msg.model) model = msg.model;
+          unavailable = false;
+        } else if (obj.usage && typeof obj.usage === "object") {
+          const usage = obj.usage;
+          inputTokens += typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+          outputTokens += typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+          if (typeof obj.model === "string" && obj.model) model = obj.model;
+          unavailable = false;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return { profileId, projectName, date, inputTokens, outputTokens, model, unavailable };
+}
+const TIMEOUT_MS = 15e3;
+const MONTH_MAP = {
+  Jan: "jan",
+  Feb: "fev",
+  Mar: "mar",
+  Apr: "abr",
+  May: "mai",
+  Jun: "jun",
+  Jul: "jul",
+  Aug: "ago",
+  Sep: "set",
+  Oct: "out",
+  Nov: "nov",
+  Dec: "dez"
+};
+function stripAnsi(str) {
+  return str.replace(/\x1B[@-_][0-?]*[ -/]*[@-~]/g, "");
+}
+function formatTime(timeStr) {
+  const withMinutes = /^(\d+):(\d+)(am|pm)$/i.exec(timeStr);
+  if (withMinutes) {
+    let h = parseInt(withMinutes[1], 10);
+    const m = withMinutes[2];
+    const period = withMinutes[3].toLowerCase();
+    if (period === "pm" && h !== 12) h += 12;
+    if (period === "am" && h === 12) h = 0;
+    return `${h.toString().padStart(2, "0")}:${m}`;
+  }
+  const hourOnly = /^(\d+)(am|pm)$/i.exec(timeStr);
+  if (hourOnly) {
+    let h = parseInt(hourOnly[1], 10);
+    const period = hourOnly[2].toLowerCase();
+    if (period === "pm" && h !== 12) h += 12;
+    if (period === "am" && h === 12) h = 0;
+    return `${h.toString().padStart(2, "0")}:00`;
+  }
+  return timeStr;
+}
+function formatResetLabel(raw) {
+  const stripped = raw.replace(/\(.*?\)/g, "").trim();
+  const weekdays = ["dom.", "seg.", "ter.", "qua.", "qui.", "sex.", "sáb."];
+  const slashMatch = /rese[a-z]*\s*(\d+)\/(\d+),\s*(\S+)/i.exec(stripped);
+  if (slashMatch) {
+    const part1 = parseInt(slashMatch[1], 10);
+    const part2 = parseInt(slashMatch[2], 10);
+    let monthIndex = -1;
+    let day = -1;
+    if (part1 > 12) {
+      day = part1;
+      monthIndex = part2 - 1;
+    } else if (part2 > 12) {
+      day = part2;
+      monthIndex = part1 - 1;
+    } else {
+      day = part1;
+      monthIndex = part2 - 1;
+    }
+    const time = formatTime(slashMatch[3]);
+    if (monthIndex >= 0 && monthIndex <= 11) {
+      const date = /* @__PURE__ */ new Date();
+      const currentYear = date.getFullYear();
+      date.setFullYear(currentYear, monthIndex, day);
+      if (date.getTime() < Date.now() - 30 * 24 * 60 * 60 * 1e3) {
+        date.setFullYear(currentYear + 1);
+      }
+      return `Reinicia ${weekdays[date.getDay()]}, ${time}`;
+    }
+  }
+  const dateMatch = /rese[a-z]*\s*([a-z0-9]+)\s*(\d+),\s*(\S+)/i.exec(stripped);
+  if (dateMatch) {
+    const monthStr = dateMatch[1].substring(0, 3).toLowerCase();
+    const isNumericMonth = !isNaN(parseInt(monthStr, 10));
+    let monthIndex = -1;
+    if (isNumericMonth) {
+      monthIndex = parseInt(monthStr, 10) - 1;
+    } else {
+      monthIndex = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"].indexOf(monthStr);
+      if (monthIndex === -1) {
+        monthIndex = ["jan", "fev", "mar", "abr", "mai", "jun", "jul", "ago", "set", "out", "nov", "dez"].indexOf(monthStr);
+      }
+    }
+    const day = parseInt(dateMatch[2], 10);
+    const time = formatTime(dateMatch[3]);
+    if (monthIndex >= 0 && monthIndex <= 11) {
+      const date = /* @__PURE__ */ new Date();
+      const currentYear = date.getFullYear();
+      date.setFullYear(currentYear, monthIndex, day);
+      if (date.getTime() < Date.now() - 30 * 24 * 60 * 60 * 1e3) {
+        date.setFullYear(currentYear + 1);
+      }
+      return `Reinicia ${weekdays[date.getDay()]}, ${time}`;
+    }
+    const monthFallback = MONTH_MAP[dateMatch[1]] ?? dateMatch[1].toLowerCase();
+    return `Reinicia em ${day}/${monthFallback} às ${time}`;
+  }
+  const timeMatch = /rese[a-z]*\s*(\S+)/i.exec(stripped);
+  if (timeMatch) {
+    return `Reinicia ${weekdays[(/* @__PURE__ */ new Date()).getDay()]}, ${formatTime(timeMatch[1])}`;
+  }
+  return raw;
+}
+function preTrustHomeDir(profileDir) {
+  const claudeJsonPath = path.join(profileDir, ".claude.json");
+  const homeDir = os.homedir().replace(/\\/g, "/");
+  try {
+    let config = {};
+    if (fs.existsSync(claudeJsonPath)) {
+      config = JSON.parse(fs.readFileSync(claudeJsonPath, "utf8"));
+    }
+    if (typeof config.projects !== "object" || config.projects === null) {
+      config.projects = {};
+    }
+    const projects = config.projects;
+    if (typeof projects[homeDir] !== "object" || projects[homeDir] === null) {
+      projects[homeDir] = {};
+    }
+    const proj = projects[homeDir];
+    if (proj.hasTrustDialogAccepted !== true) {
+      proj.hasTrustDialogAccepted = true;
+      fs.writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2), "utf8");
+    }
+    if (!config.theme) {
+      config.theme = "dark";
+      fs.writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2), "utf8");
+    }
+  } catch (err) {
+    console.warn("[quota-service] preTrustHomeDir failed:", err);
+  }
+}
+function preDisableInteractiveContext(profileDir) {
+  const claudeJsonPath = path.join(profileDir, ".claude.json");
+  try {
+    if (!fs.existsSync(claudeJsonPath)) return false;
+    const config = JSON.parse(fs.readFileSync(claudeJsonPath, "utf8"));
+    const features = config.cachedGrowthBookFeatures;
+    if (features?.tengu_oboe !== true) return false;
+    features.tengu_oboe = false;
+    fs.writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2), "utf8");
+    return true;
+  } catch (err) {
+    console.warn("[quota-service] preDisableInteractiveContext failed:", err);
+    return false;
+  }
+}
+function restoreInteractiveContext(profileDir) {
+  const claudeJsonPath = path.join(profileDir, ".claude.json");
+  try {
+    const config = JSON.parse(fs.readFileSync(claudeJsonPath, "utf8"));
+    const features = config.cachedGrowthBookFeatures;
+    if (!features) return;
+    features.tengu_oboe = true;
+    fs.writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2), "utf8");
+  } catch (err) {
+    console.warn("[quota-service] restoreInteractiveContext failed:", err);
+  }
+}
+function parseOutput$1(raw) {
+  const clean = stripAnsi(raw);
+  const sessionPct = /current\s*session[\s\S]*?(\d+)%\s*used/i.exec(clean);
+  const sessionReset = /current\s*session[\s\S]*?(rese[a-z]*\s*.*?\([^)]+\))/i.exec(clean);
+  const weekPct = /current\s*week[\s\S]*?(\d+)%\s*used/i.exec(clean);
+  const weekReset = /current\s*week[\s\S]*?(rese[a-z]*\s*.*?\([^)]+\))/i.exec(clean);
+  if (sessionPct && weekPct) {
+    return {
+      session: {
+        percent: parseInt(sessionPct[1], 10),
+        resetLabel: sessionReset ? formatResetLabel(sessionReset[1]) : ""
+      },
+      week: {
+        percent: parseInt(weekPct[1], 10),
+        resetLabel: weekReset ? formatResetLabel(weekReset[1]) : ""
+      }
+    };
+  }
+  const rateLimitMatch = /you.{0,40}limit[\s\S]{0,400}?(rese[a-z]*\s*\w+\s*\d+,\s*\S+\s*\()/i.exec(clean);
+  if (rateLimitMatch) {
+    const rawMatch = rateLimitMatch[1];
+    const dateMatch = /rese[a-z]*\s*(\w+)\s*(\d+),\s*(\S+)\s*\(/i.exec(rawMatch);
+    if (dateMatch) {
+      const resetLabel = formatResetLabel(`Resets ${dateMatch[1]} ${dateMatch[2]}, ${dateMatch[3]}`);
+      return {
+        session: { percent: 100, resetLabel },
+        week: { percent: 100, resetLabel }
+      };
+    }
+  }
+  return null;
+}
+let ptyMutex = Promise.resolve();
+async function withPtyLock(fn) {
+  const oldLock = ptyMutex;
+  let release = () => {
+  };
+  ptyMutex = new Promise((resolve) => {
+    release = resolve;
+  });
+  await oldLock;
+  try {
+    return await fn();
+  } finally {
+    setTimeout(release, 1e3);
+  }
+}
+function getQuota(profileId) {
+  return withPtyLock(() => new Promise((resolve) => {
+    const profileDir = getProfileDir(profileId);
+    preTrustHomeDir(profileDir);
+    const contextWasDisabled = preDisableInteractiveContext(profileDir);
+    const { file, args } = getClaudeSpawnConfig();
+    let spawnFile;
+    let spawnArgs;
+    if (args.length > 0 && args[0] === "/c") {
+      spawnFile = file;
+      spawnArgs = [...args];
+    } else if (args.length > 0 && args[0] === "/k") {
+      spawnFile = file;
+      spawnArgs = ["/c", "claude"];
+    } else if (args.length > 0) {
+      spawnFile = file;
+      spawnArgs = [...args];
+    } else {
+      spawnFile = file;
+      spawnArgs = [];
+    }
+    const env = { ...process.env, CLAUDE_CONFIG_DIR: profileDir, NODE_ENV: void 0, CI: "true" };
+    let output = "";
+    let done = false;
+    let trustConfirmed = false;
+    let escSent = false;
+    let usageSent = false;
+    const finish = (_reason) => {
+      if (!done) {
+        done = true;
+        clearTimeout(timer);
+        try {
+          term.kill();
+        } catch {
+        }
+        if (contextWasDisabled) restoreInteractiveContext(profileDir);
+        const parsed = parseOutput$1(output);
+        resolve(parsed);
+      }
+    };
+    const term = nodePty.spawn(spawnFile, spawnArgs, {
+      name: "xterm-color",
+      cols: 120,
+      rows: 30,
+      cwd: os.homedir(),
+      env
+    });
+    const timer = setTimeout(() => finish("timeout"), TIMEOUT_MS);
+    term.onData((data) => {
+      output += data;
+      const clean = stripAnsi(output);
+      const cleanLower = clean.toLowerCase();
+      if (!trustConfirmed && cleanLower.includes("trustthisfolder")) {
+        trustConfirmed = true;
+        setTimeout(() => {
+          try {
+            term.write("1\r");
+          } catch {
+          }
+        }, 150);
+        return;
+      }
+      if (!escSent && !done && (clean.includes("❯") || clean.includes("?")) && !cleanLower.includes("what do you want")) {
+        if (!escSent && !usageSent) {
+          usageSent = true;
+          setTimeout(() => {
+            try {
+              term.write("/usage");
+              setTimeout(() => {
+                try {
+                  term.write("\r");
+                  setTimeout(() => {
+                    try {
+                      term.write("\r");
+                    } catch {
+                    }
+                  }, 500);
+                } catch {
+                }
+              }, 500);
+            } catch {
+            }
+          }, 1500);
+        }
+      }
+      if (usageSent && !escSent && !done) {
+        if (parseOutput$1(clean) !== null) {
+          escSent = true;
+          setTimeout(() => {
+            try {
+              term.write("\x1B");
+            } catch {
+            }
+            setTimeout(() => {
+              finish("success");
+            }, 300);
+          }, 200);
+        }
+      }
+      if (!escSent && !done && /entertoselect/i.test(cleanLower) && /esctocancel/i.test(cleanLower)) {
+        escSent = true;
+        setTimeout(() => {
+          try {
+            term.write("\x1B");
+          } catch {
+          }
+        }, 150);
+      }
+    });
+    term.onExit(() => {
+      finish("exit");
+    });
+  }));
+}
+function getEmail(profileId) {
+  const profileDir = getProfileDir(profileId);
+  const claudeJsonPath = path.join(profileDir, ".claude.json");
+  try {
+    if (fs.existsSync(claudeJsonPath)) {
+      const config = JSON.parse(fs.readFileSync(claudeJsonPath, "utf8"));
+      if (config.email) {
+        return Promise.resolve(config.email);
+      }
+    }
+  } catch (e) {
+    console.warn("[getEmail] Erro ao ler cache", e);
+  }
+  return withPtyLock(() => new Promise((resolve) => {
+    preTrustHomeDir(profileDir);
+    const contextWasDisabled = preDisableInteractiveContext(profileDir);
+    const { file, args } = getClaudeSpawnConfig();
+    let spawnFile = file;
+    let spawnArgs = args.length > 0 && args[0] === "/k" ? ["/c", "claude"] : [...args];
+    if (spawnArgs.length === 0) spawnArgs = [];
+    const env = { ...process.env, CLAUDE_CONFIG_DIR: profileDir, NODE_ENV: void 0, CI: "true" };
+    let output = "";
+    let done = false;
+    let trustConfirmed = false;
+    let escSent = false;
+    let statusSent = false;
+    const term = nodePty.spawn(spawnFile, spawnArgs, {
+      name: "xterm-color",
+      cols: 120,
+      rows: 30,
+      cwd: os.homedir(),
+      env
+    });
+    const finish = (_reason) => {
+      if (!done) {
+        done = true;
+        clearTimeout(timer);
+        try {
+          term.kill();
+        } catch {
+        }
+        if (contextWasDisabled) restoreInteractiveContext(profileDir);
+        const clean = stripAnsi(output);
+        const emailMatch = /Email:\s*([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})(?:Model)?/i.exec(clean);
+        let email = emailMatch ? emailMatch[1].trim() : null;
+        if (email && email.toLowerCase().endsWith("model")) {
+          email = email.slice(0, -5).trim();
+        }
+        if (email) {
+          try {
+            let config = {};
+            if (fs.existsSync(claudeJsonPath)) {
+              config = JSON.parse(fs.readFileSync(claudeJsonPath, "utf8"));
+            }
+            config.email = email;
+            fs.writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2), "utf8");
+          } catch (e) {
+            console.warn("[getEmail] Erro ao salvar cache", e);
+          }
+        }
+        resolve(email);
+      }
+    };
+    const timer = setTimeout(() => finish("timeout"), TIMEOUT_MS);
+    term.onData((data) => {
+      if (done) return;
+      output += data;
+      const clean = stripAnsi(output);
+      const cleanLower = clean.toLowerCase();
+      if (!trustConfirmed && cleanLower.includes("trustthisfolder")) {
+        trustConfirmed = true;
+        setTimeout(() => {
+          try {
+            term.write("1\r");
+          } catch {
+          }
+        }, 150);
+        return;
+      }
+      if (!escSent && !done && (clean.includes("❯") || clean.includes("?")) && !cleanLower.includes("what do you want")) {
+        if (!escSent && !statusSent) {
+          statusSent = true;
+          setTimeout(() => {
+            try {
+              term.write("/status");
+              setTimeout(() => {
+                try {
+                  term.write("\r");
+                  setTimeout(() => {
+                    try {
+                      term.write("\r");
+                    } catch {
+                    }
+                  }, 500);
+                } catch {
+                }
+              }, 500);
+            } catch {
+            }
+          }, 1500);
+        }
+      }
+      if (statusSent && !escSent && !done) {
+        if (clean.includes("Login method:") || clean.includes("Email:")) {
+          escSent = true;
+          setTimeout(() => {
+            try {
+              term.write("\x1B");
+            } catch {
+            }
+            setTimeout(() => finish("success"), 300);
+          }, 500);
+        }
+      }
+    });
+  }));
+}
+function isValidAgentFilename(filename) {
+  return /^[a-z0-9_-]+\.md$/.test(filename);
+}
+function registerFilesystemHandlers() {
+  electron.ipcMain.handle("profile:createDirectory", async (_event, profileId) => {
+    if (typeof profileId !== "string" || !profileId.trim()) {
+      throw new Error("profileId inválido");
+    }
+    await createProfileDirectory(profileId);
+    return { success: true };
+  });
+  electron.ipcMain.handle("profile:directoryExists", (_event, profileId) => {
+    if (typeof profileId !== "string" || !profileId.trim()) return false;
+    return profileDirectoryExists(profileId);
+  });
+  electron.ipcMain.handle("profile:hasCredentials", (_event, profileId) => {
+    if (typeof profileId !== "string" || !profileId.trim()) return false;
+    return profileHasCredentials(profileId);
+  });
+  electron.ipcMain.handle("fs:injectContext", (_event, claudeMdPath, summaryContent) => {
+    if (typeof claudeMdPath !== "string" || !claudeMdPath.trim()) {
+      throw new Error("claudeMdPath inválido");
+    }
+    if (typeof summaryContent !== "string") {
+      throw new Error("summaryContent inválido");
+    }
+    injectContext(claudeMdPath, summaryContent);
+    return { success: true };
+  });
+  electron.ipcMain.handle("fs:cleanContext", (_event, claudeMdPath) => {
+    if (typeof claudeMdPath !== "string" || !claudeMdPath.trim()) return { success: false };
+    try {
+      cleanContext(claudeMdPath);
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  });
+  electron.ipcMain.handle("fs:hasContextMarkers", (_event, claudeMdPath) => {
+    if (typeof claudeMdPath !== "string" || !claudeMdPath.trim()) return false;
+    return hasContextMarkers(claudeMdPath);
+  });
+  electron.ipcMain.handle("fs:readAgents", async () => {
+    const agentsDir = getAgentsDir();
+    if (!fs.existsSync(agentsDir)) return [];
+    const files = fs.readdirSync(agentsDir).filter((f) => f.endsWith(".md"));
+    return files.map((filename) => {
+      const filePath = path.join(agentsDir, filename);
+      const content = fs.readFileSync(filePath, "utf-8");
+      const preview = content.split("\n").find((l) => l.trim().length > 0) ?? "";
+      return { filename, preview: preview.slice(0, 120) };
+    });
+  });
+  electron.ipcMain.handle("fs:readAgent", (_event, filename) => {
+    if (typeof filename !== "string" || !isValidAgentFilename(filename)) return null;
+    const filePath = path.join(getAgentsDir(), filename);
+    if (!fs.existsSync(filePath)) return null;
+    return fs.readFileSync(filePath, "utf-8");
+  });
+  electron.ipcMain.handle("fs:writeAgent", (_event, filename, content, overwrite) => {
+    if (typeof filename !== "string" || !isValidAgentFilename(filename)) {
+      throw new Error("Nome de arquivo inválido. Use apenas letras minúsculas, números, hífens e underscores.");
+    }
+    if (typeof content !== "string") {
+      throw new Error("Conteúdo inválido");
+    }
+    const agentsDir = getAgentsDir();
+    const filePath = path.join(agentsDir, filename);
+    if (!overwrite && fs.existsSync(filePath)) {
+      throw new Error(`Já existe um agent com este nome: ${filename}`);
+    }
+    if (!fs.existsSync(agentsDir)) {
+      fs.mkdirSync(agentsDir, { recursive: true });
+    }
+    try {
+      fs.writeFileSync(filePath, content, "utf-8");
+    } catch (err) {
+      const nodeErr = err;
+      if (nodeErr.code === "EACCES") {
+        throw new Error(`Sem permissão para escrever em ${filePath}. Verifique as permissões do arquivo.`);
+      }
+      throw err;
+    }
+    return { success: true };
+  });
+  electron.ipcMain.handle("fs:deleteAgent", (_event, filename) => {
+    if (typeof filename !== "string" || !isValidAgentFilename(filename)) {
+      throw new Error("Nome de arquivo inválido");
+    }
+    const filePath = path.join(getAgentsDir(), filename);
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Agent não encontrado: ${filename}`);
+    }
+    try {
+      fs.unlinkSync(filePath);
+    } catch (err) {
+      const nodeErr = err;
+      if (nodeErr.code === "EACCES") {
+        throw new Error(`Sem permissão para deletar ${filePath}. Verifique as permissões do arquivo.`);
+      }
+      throw err;
+    }
+    return { success: true };
+  });
+  electron.ipcMain.handle("fs:readClaudeMd", () => {
+    const mdPath = getGlobalClaudeMdPath();
+    if (!fs.existsSync(mdPath)) return { exists: false, content: "" };
+    const content = fs.readFileSync(mdPath, "utf-8");
+    return { exists: true, content };
+  });
+  electron.ipcMain.handle("fs:writeClaudeMd", (_event, content) => {
+    if (typeof content !== "string") {
+      throw new Error("Conteúdo inválido");
+    }
+    const mdPath = getGlobalClaudeMdPath();
+    try {
+      fs.writeFileSync(mdPath, content, "utf-8");
+    } catch (err) {
+      const nodeErr = err;
+      if (nodeErr.code === "EACCES") {
+        throw new Error(`Sem permissão para escrever em ${mdPath}. Verifique as permissões do arquivo.`);
+      }
+      throw err;
+    }
+    return { success: true };
+  });
+  electron.ipcMain.handle("usage:aggregate", () => {
+    return aggregateTokens();
+  });
+  electron.ipcMain.handle("quota:get", async (_event, profileId) => {
+    if (typeof profileId !== "string" || !profileId.trim()) return null;
+    return getQuota(profileId);
+  });
+  electron.ipcMain.handle("quota:getEmail", async (_event, profileId) => {
+    if (typeof profileId !== "string" || !profileId.trim()) return null;
+    return getEmail(profileId);
+  });
+}
+const CONTEXT_PERCENT_RE = /(\d+)%\s+of\s+context\s+window\s+used/i;
+const CONTEXT_TOKENS_RE = /context\s+window[:\s]+(\d+)\s*\/\s*(\d+)\s*tokens/i;
+const CONTEXT_SLASH_CMD_RE = /\d+[a-zA-Z]?\/\d+[a-zA-Z]?\s+tokens\s+\(([\d.]+)%\)/i;
+const RATE_LIMIT_PATTERNS = [
+  /rate\s+limit/i,
+  /api\s+rate\s+limit/i,
+  /429/,
+  /you\s+have\s+reached\s+your\s+daily\s+limit/i,
+  /usage\s+limit/i,
+  /too\s+many\s+requests/i
+];
+function parseOutput(output, sessionId, win, onContextPercent) {
+  const percentMatch = CONTEXT_PERCENT_RE.exec(output);
+  if (percentMatch) {
+    const percent = Math.min(100, Math.max(0, parseInt(percentMatch[1], 10)));
+    win.webContents.send("monitor:contextUsage", { sessionId, percent });
+    onContextPercent?.(sessionId, percent);
+    return;
+  }
+  const tokensMatch = CONTEXT_TOKENS_RE.exec(output);
+  if (tokensMatch) {
+    const used = parseInt(tokensMatch[1], 10);
+    const total = parseInt(tokensMatch[2], 10);
+    if (total > 0) {
+      const percent = Math.min(100, Math.round(used / total * 100));
+      win.webContents.send("monitor:contextUsage", { sessionId, percent });
+      onContextPercent?.(sessionId, percent);
+    }
+    return;
+  }
+  const slashMatch = CONTEXT_SLASH_CMD_RE.exec(output);
+  if (slashMatch) {
+    const percent = Math.min(100, Math.max(0, Math.round(parseFloat(slashMatch[1]))));
+    win.webContents.send("monitor:contextUsage", { sessionId, percent });
+    onContextPercent?.(sessionId, percent);
+    return;
+  }
+  for (const pattern of RATE_LIMIT_PATTERNS) {
+    if (pattern.test(output)) {
+      win.webContents.send("monitor:rateLimit", { sessionId });
+      return;
+    }
+  }
+}
+const MODEL_IDS = {
+  opus: "claude-opus-4-6",
+  sonnet: "claude-sonnet-4-6",
+  haiku: "claude-haiku-4-5-20251001"
+};
+const sessions = /* @__PURE__ */ new Map();
+function detectProject(cwd) {
+  try {
+    const toplevel = child_process.execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf8",
+      timeout: 3e3
+    }).trim();
+    return { projectPath: toplevel, projectName: path.basename(toplevel) };
+  } catch {
+    return { projectPath: cwd, projectName: path.basename(cwd) };
+  }
+}
+function startSession(payload) {
+  const { profileId, profileName, workingDirectory, model = "sonnet" } = payload;
+  const existingEntry = Array.from(sessions.values()).find(
+    (e) => e.session.profileId === profileId
+  );
+  if (existingEntry) return existingEntry.session;
+  const sessionId = crypto.randomUUID();
+  const profileDir = getProfileDir(profileId);
+  const { projectPath, projectName } = detectProject(workingDirectory || os.homedir());
+  const { file, args } = getClaudeSpawnConfig();
+  const env = {
+    ...process.env,
+    CLAUDE_CONFIG_DIR: profileDir,
+    ANTHROPIC_MODEL: MODEL_IDS[model],
+    // Remove variáveis que podem interferir com o output do Claude Code
+    NODE_ENV: void 0
+  };
+  const ptyProcess = nodePty.spawn(file, args, {
+    name: "xterm-color",
+    cols: 80,
+    rows: 24,
+    cwd: projectPath,
+    env
+  });
+  const session = {
+    id: sessionId,
+    profileId,
+    profileName,
+    projectPath,
+    projectName,
+    pid: ptyProcess.pid ?? null,
+    model,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    contextPercent: 0,
+    status: "connecting"
+  };
+  ptyProcess.onData((data) => {
+    const win = getMainWindow();
+    if (win) {
+      win.webContents.send("terminal:output", { sessionId, data });
+      parseOutput(data, sessionId, win, updateContextPercent);
+    }
+  });
+  ptyProcess.onExit(() => {
+    const entry = sessions.get(sessionId);
+    if (entry) {
+      entry.session.status = "ended";
+      sessions.delete(sessionId);
+    }
+    const win = getMainWindow();
+    win?.webContents.send("session:ended", { sessionId });
+  });
+  session.status = "active";
+  sessions.set(sessionId, { session, pty: ptyProcess });
+  return session;
+}
+function killSession(sessionId) {
+  const entry = sessions.get(sessionId);
+  if (!entry) return false;
+  try {
+    entry.pty.kill();
+  } catch {
+  }
+  sessions.delete(sessionId);
+  return true;
+}
+function listSessions() {
+  return Array.from(sessions.values()).map((e) => e.session);
+}
+function writeToSession(sessionId, data) {
+  const entry = sessions.get(sessionId);
+  if (!entry) return false;
+  entry.pty.write(data);
+  return true;
+}
+function resizeSession(sessionId, cols, rows) {
+  const entry = sessions.get(sessionId);
+  if (!entry) return false;
+  entry.pty.resize(cols, rows);
+  return true;
+}
+function updateContextPercent(sessionId, percent) {
+  const entry = sessions.get(sessionId);
+  if (entry) entry.session.contextPercent = percent;
+}
+function registerSessionHandlers() {
+  electron.ipcMain.handle("session:start", (_event, payload) => {
+    return startSession(payload);
+  });
+  electron.ipcMain.handle("session:kill", (_event, sessionId) => {
+    return killSession(sessionId);
+  });
+  electron.ipcMain.handle("session:list", () => {
+    return listSessions();
+  });
+}
+function registerTerminalHandlers() {
+  electron.ipcMain.on("terminal:input", (_event, sessionId, data) => {
+    writeToSession(sessionId, data);
+  });
+  electron.ipcMain.on("terminal:resize", (_event, sessionId, cols, rows) => {
+    resizeSession(sessionId, cols, rows);
+  });
+}
+const SERVICE = "ai-solution-exp";
+async function setToken(profileId, token) {
+  await keytar.setPassword(SERVICE, profileId, token);
+}
+async function getToken(profileId) {
+  return keytar.getPassword(SERVICE, profileId);
+}
+async function deleteToken(profileId) {
+  return keytar.deletePassword(SERVICE, profileId);
+}
+function registerKeychainHandlers() {
+  electron.ipcMain.handle("keychain:set", (_event, profileId, token) => {
+    return setToken(profileId, token);
+  });
+  electron.ipcMain.handle("keychain:get", (_event, profileId) => {
+    return getToken(profileId);
+  });
+  electron.ipcMain.handle("keychain:delete", (_event, profileId) => {
+    return deleteToken(profileId);
+  });
+}
+function registerHistoryHandlers() {
+  electron.ipcMain.handle("history:listProjects", (_event, profileId) => {
+    if (typeof profileId !== "string" || !profileId.trim()) return [];
+    return listProjects(profileId);
+  });
+  electron.ipcMain.handle("history:listSummaries", (_event, profileId, projectName) => {
+    if (typeof profileId !== "string" || !profileId.trim()) return [];
+    if (typeof projectName !== "string" || !projectName.trim()) return [];
+    return listSummaries(profileId, projectName);
+  });
+  electron.ipcMain.handle("history:readSummary", (_event, filePath) => {
+    if (typeof filePath !== "string" || !filePath.trim()) return null;
+    return readSummary(filePath);
+  });
+  electron.ipcMain.handle(
+    "history:saveSummary",
+    (_event, profileId, projectName, content) => {
+      if (typeof profileId !== "string" || !profileId.trim()) throw new Error("profileId inválido");
+      if (typeof projectName !== "string" || !projectName.trim())
+        throw new Error("projectName inválido");
+      if (typeof content !== "string") throw new Error("content inválido");
+      return saveSummary(profileId, projectName, content);
+    }
+  );
+  electron.ipcMain.handle("history:detectOrphan", (_event, profileId) => {
+    if (typeof profileId !== "string" || !profileId.trim()) return [];
+    return detectOrphanSessions(profileId);
+  });
+  electron.ipcMain.handle("history:readOrphanContent", (_event, jsonlPath) => {
+    if (typeof jsonlPath !== "string" || !jsonlPath.trim()) return null;
+    return readOrphanContent(jsonlPath);
+  });
+  electron.ipcMain.handle("history:listNativeSessions", () => {
+    return listNativeSessions();
+  });
+  electron.ipcMain.handle("history:readNativeSessionConversation", (_event, sessionId) => {
+    if (typeof sessionId !== "string" || !sessionId.trim()) return [];
+    return readNativeSessionConversation(sessionId);
+  });
+}
+function registerSummaryHandlers() {
+  electron.ipcMain.handle("summary:generate", async (_event, payload) => {
+    const p = payload;
+    if (typeof p?.profileId !== "string" || !p.profileId.trim()) {
+      throw new Error("profileId inválido");
+    }
+    if (typeof p?.projectName !== "string" || !p.projectName.trim()) {
+      throw new Error("projectName inválido");
+    }
+    if (typeof p?.projectPath !== "string") {
+      throw new Error("projectPath inválido");
+    }
+    return generateSummary(p);
+  });
+}
+function registerWindowHandlers() {
+  electron.ipcMain.on("window:minimize", () => {
+    getMainWindow()?.minimize();
+  });
+  electron.ipcMain.on("window:maximize", () => {
+    const win = getMainWindow();
+    if (!win) return;
+    if (win.isMaximized()) {
+      win.unmaximize();
+    } else {
+      win.maximize();
+    }
+  });
+  electron.ipcMain.on("window:close", () => {
+    getMainWindow()?.close();
+  });
+  electron.ipcMain.handle("window:isMaximized", () => {
+    return getMainWindow()?.isMaximized() ?? false;
+  });
+}
+function registerIpcHandlers() {
+  electron.ipcMain.handle("ping", () => "pong");
+  registerWindowHandlers();
+  registerClaudeCheckHandlers();
+  registerFilesystemHandlers();
+  registerSessionHandlers();
+  registerTerminalHandlers();
+  registerKeychainHandlers();
+  registerHistoryHandlers();
+  registerSummaryHandlers();
+}
+const gotTheLock = electron.app.requestSingleInstanceLock();
+if (!gotTheLock) {
+  electron.app.quit();
+} else {
+  electron.app.on("second-instance", () => {
+    const win = getMainWindow();
+    if (win) {
+      if (win.isMinimized()) win.restore();
+      win.focus();
+    }
+  });
+  electron.app.whenReady().then(() => {
+    if (!process.env["ELECTRON_RENDERER_URL"]) {
+      electron.session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
+        callback({
+          responseHeaders: {
+            ...details.responseHeaders,
+            "Content-Security-Policy": [
+              "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; connect-src 'self' wss: https:; font-src 'self' data:;"
+            ]
+          }
+        });
+      });
+    }
+    registerIpcHandlers();
+    createMainWindow();
+  });
+  electron.app.on("window-all-closed", () => {
+    if (process.platform !== "darwin") electron.app.quit();
+  });
+  electron.app.on("activate", () => {
+    if (electron.BrowserWindow.getAllWindows().length === 0) createMainWindow();
+  });
+  electron.app.on("before-quit", () => {
+  });
+}