shiva-code 0.8.10 → 0.8.12

package/dist/index.js

@@ -3361,7 +3361,7 @@ var repairCommand = new Command9("repair").description("Repariert SHIVA-Konfigur
 
 // src/commands/session/start.ts
 import { Command as Command10 } from "commander";
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as path3 from "path";
 import ora8 from "ora";
 import { spawnSync as spawnSync4 } from "child_process";
@@ -3370,6 +3370,7 @@ import { spawnSync as spawnSync4 } from "child_process";
 import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
 import * as path2 from "path";
 import * as os2 from "os";
+import * as fs from "fs";
 
 // src/services/infrastructure/docker.ts
 import { spawn, spawnSync } from "child_process";
@@ -3446,8 +3447,8 @@ var DockerService = class {
     ];
     for (const socketPath of possiblePaths) {
       try {
-        const fs15 = __require("fs");
-        if (fs15.existsSync(socketPath)) {
+        const fs16 = __require("fs");
+        if (fs16.existsSync(socketPath)) {
           return socketPath;
         }
       } catch {
@@ -4117,6 +4118,29 @@ var DockerService = class {
 var dockerService = new DockerService();
 
 // src/services/infrastructure/terminal.ts
+function cleanupTmuxSockets() {
+  try {
+    const tmpDir = "/tmp";
+    const files = fs.readdirSync(tmpDir);
+    const uid = process.getuid?.() ?? 0;
+    for (const file of files) {
+      if (file.startsWith("tmux-") && file.includes(String(uid))) {
+        const socketPath = path2.join(tmpDir, file);
+        try {
+          const stats = fs.statSync(socketPath);
+          if (stats.isDirectory()) {
+            const result = spawnSync2("tmux", ["list-sessions"], { stdio: "pipe" });
+            if (result.status !== 0) {
+              fs.rmSync(socketPath, { recursive: true, force: true });
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
 function commandExists(command) {
   try {
     if (!/^[a-zA-Z0-9_-]+$/.test(command)) {
@@ -4189,6 +4213,7 @@ function sanitizeProjectName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "-").substring(0, 50);
 }
 async function spawnInTmux(projects, sessionName) {
+  cleanupTmuxSockets();
   const tmuxSession = sessionName || `shiva-${Date.now()}`;
   const insideTmux = isInsideTmux();
   for (let i = 0; i < projects.length; i++) {
@@ -4201,16 +4226,12 @@ async function spawnInTmux(projects, sessionName) {
     const claudeArgs = buildClaudeArgs(project);
     const safeName = sanitizeProjectName(project.projectName);
     if (insideTmux) {
-      spawnSync2("tmux", [
-        "new-window",
-        "-n",
-        safeName,
-        "-c",
-        project.projectPath,
-        "claude",
-        ...claudeArgs
-      ], { stdio: "ignore" });
-      spawnSync2("tmux", ["select-window", "-t", safeName], { stdio: "ignore" });
+      spawnSync2("tmux", ["rename-window", safeName], { stdio: "ignore" });
+      spawnSync2("claude", claudeArgs, {
+        stdio: "inherit",
+        cwd: project.projectPath
+      });
+      return;
     } else {
       if (i === 0) {
         spawnSync2("tmux", [
@@ -4539,7 +4560,7 @@ function getTerminalName(terminal) {
 }
 
 // src/services/sandbox/sandbox.ts
-import { existsSync as existsSync8, mkdirSync, rmSync, readdirSync as readdirSync2, copyFileSync, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync8, mkdirSync, rmSync as rmSync2, readdirSync as readdirSync3, copyFileSync, readFileSync as readFileSync4 } from "fs";
 import { join as join4, dirname } from "path";
 import { randomUUID } from "crypto";
 import Conf2 from "conf";
@@ -4834,7 +4855,7 @@ var SandboxService = class {
    * Recursively copy a directory
    */
   copyDirectory(src, dest, excludePaths) {
-    const entries = readdirSync2(src, { withFileTypes: true });
+    const entries = readdirSync3(src, { withFileTypes: true });
     for (const entry of entries) {
       const srcPath = join4(src, entry.name);
       const destPath = join4(dest, entry.name);
@@ -4928,13 +4949,13 @@ var SandboxService = class {
       const removeResult = gitExec(["worktree", "remove", session.sandboxPath, "--force"], session.projectPath);
       if (!removeResult.success) {
         if (existsSync8(session.sandboxPath)) {
-          rmSync(session.sandboxPath, { recursive: true, force: true });
+          rmSync2(session.sandboxPath, { recursive: true, force: true });
         }
         gitExec(["worktree", "prune"], session.projectPath);
       }
     } else {
       if (existsSync8(session.sandboxPath)) {
-        rmSync(session.sandboxPath, { recursive: true, force: true });
+        rmSync2(session.sandboxPath, { recursive: true, force: true });
       }
     }
     const sessions = store.get("sessions");
@@ -5010,7 +5031,7 @@ var SandboxService = class {
     const sandboxEntries = /* @__PURE__ */ new Set();
     const sandboxFullPath = join4(sandboxPath, relativePath);
     if (existsSync8(sandboxFullPath)) {
-      const entries = readdirSync2(sandboxFullPath, { withFileTypes: true });
+      const entries = readdirSync3(sandboxFullPath, { withFileTypes: true });
       for (const entry of entries) {
         if (config.excludePaths.includes(entry.name) || entry.name === ".shiva") {
           continue;
@@ -5054,7 +5075,7 @@ var SandboxService = class {
     }
     const originalFullPath = join4(originalPath, relativePath);
     if (existsSync8(originalFullPath)) {
-      const entries = readdirSync2(originalFullPath, { withFileTypes: true });
+      const entries = readdirSync3(originalFullPath, { withFileTypes: true });
       for (const entry of entries) {
         if (config.excludePaths.includes(entry.name) || entry.name === ".shiva") {
           continue;
@@ -5100,7 +5121,7 @@ var SandboxService = class {
    * Count changes for a new directory
    */
   async countNewDirectoryChanges(dirPath, relativePath, changes) {
-    const entries = readdirSync2(dirPath, { withFileTypes: true });
+    const entries = readdirSync3(dirPath, { withFileTypes: true });
     const config = this.getConfig();
     for (const entry of entries) {
       if (config.excludePaths.includes(entry.name)) continue;
@@ -5124,7 +5145,7 @@ var SandboxService = class {
    * Count changes for a deleted directory
    */
   async countDeletedDirectoryChanges(dirPath, relativePath, changes) {
-    const entries = readdirSync2(dirPath, { withFileTypes: true });
+    const entries = readdirSync3(dirPath, { withFileTypes: true });
     const config = this.getConfig();
     for (const entry of entries) {
       if (config.excludePaths.includes(entry.name)) continue;
@@ -5228,7 +5249,7 @@ ${content.split("\n").map((l) => `- ${l}`).join("\n")}`;
       const destPath = join4(session.projectPath, filePath);
       if (change.type === "deleted") {
         if (existsSync8(destPath)) {
-          rmSync(destPath, { force: true });
+          rmSync2(destPath, { force: true });
         }
       } else {
         if (existsSync8(srcPath)) {
@@ -5268,7 +5289,7 @@ ${content.split("\n").map((l) => `- ${l}`).join("\n")}`;
         copyFileSync(originalPath, sandboxFilePath);
       } else {
         if (existsSync8(sandboxFilePath)) {
-          rmSync(sandboxFilePath, { force: true });
+          rmSync2(sandboxFilePath, { force: true });
         }
       }
     }
@@ -5361,7 +5382,7 @@ var startCommand = new Command10("start").description("Projekte starten (mit Git
     const launches = [];
     for (const projektArg of projekte) {
       const absolutePath = path3.resolve(projektArg);
-      if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isDirectory()) {
+      if (fs2.existsSync(absolutePath) && fs2.statSync(absolutePath).isDirectory()) {
         const project = findProjectFromArray(allProjects, absolutePath);
         const latestSession = project?.latestSession;
         launches.push({
@@ -5373,7 +5394,7 @@ var startCommand = new Command10("start").description("Projekte starten (mit Git
       } else {
         const project = findProjectFromArray(allProjects, projektArg);
         if (project) {
-          if (!fs.existsSync(project.absolutePath)) {
+          if (!fs2.existsSync(project.absolutePath)) {
             spinner.warn(`Projektpfad existiert nicht: ${project.absolutePath}`);
             continue;
           }
@@ -5522,7 +5543,7 @@ async function startIssueSession(issueNumber, options) {
   let foundIssue = null;
   let repoFullName = null;
   for (const project of allProjects) {
-    if (!fs.existsSync(project.absolutePath)) continue;
+    if (!fs2.existsSync(project.absolutePath)) continue;
     const repo = getRepoInfo(project.absolutePath);
     if (!repo) continue;
     const issue = getIssue(repo.fullName, issueNumber);
@@ -5631,7 +5652,7 @@ async function startPRSession(prNumber, options) {
   let foundPR = null;
   let repoFullName = null;
   for (const project of allProjects) {
-    if (!fs.existsSync(project.absolutePath)) continue;
+    if (!fs2.existsSync(project.absolutePath)) continue;
     const repo = getRepoInfo(project.absolutePath);
     if (!repo) continue;
     const pr = getPR(repo.fullName, prNumber);
@@ -5732,7 +5753,7 @@ import { Command as Command11 } from "commander";
 import { spawn as spawn4 } from "child_process";
 import inquirer4 from "inquirer";
 import ora9 from "ora";
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 var resumeCommand = new Command11("resume").description("Neueste Claude Code Session fortsetzen").argument("[projekt]", "Projektname oder Pfad").option("-s, --session <id>", "Bestimmte Session-ID fortsetzen").option("-b, --branch", "Session f\xFCr aktuellen Branch verwenden").option("-l, --list", "Sessions zur Auswahl anzeigen").option("--save-mapping", "Branch-Session Mapping speichern").action(async (projekt, options) => {
   try {
     let project = null;
@@ -5824,7 +5845,7 @@ var resumeCommand = new Command11("resume").description("Neueste Claude Code Ses
       log.error("Kein Projekt gefunden");
       return;
     }
-    if (!fs2.existsSync(project.absolutePath)) {
+    if (!fs3.existsSync(project.absolutePath)) {
       log.error(`Projektpfad existiert nicht mehr: ${project.absolutePath}`);
       return;
     }
@@ -5955,7 +5976,7 @@ import { Command as Command12 } from "commander";
 import { spawn as spawn5 } from "child_process";
 import inquirer5 from "inquirer";
 import ora10 from "ora";
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 var restoreCommand = new Command12("restore").description("Context aus crashed Session wiederherstellen").argument("[projekt]", "Projektname oder Pfad").option("--level <level>", "Recovery-Level: minimal, standard, full", "standard").option("-o, --output <pfad>", "Ausgabeverzeichnis f\xFCr Recovery-Datei").option("--no-prompt", "Keine neue Session starten").action(async (projekt, options) => {
   try {
     let project = null;
@@ -6032,7 +6053,7 @@ var restoreCommand = new Command12("restore").description("Context aus crashed S
     const statusText = corrupted ? colors.red("Corrupted") : colors.green("OK");
     let fileSize = "unbekannt";
     try {
-      const stats = fs3.statSync(session.fullPath);
+      const stats = fs4.statSync(session.fullPath);
       const sizeMB = (stats.size / (1024 * 1024)).toFixed(1);
       fileSize = `${sizeMB}MB`;
     } catch {
@@ -6064,7 +6085,7 @@ var restoreCommand = new Command12("restore").description("Context aus crashed S
         log.newline();
       }
       if (options.prompt !== false) {
-        const projectExists = fs3.existsSync(project.absolutePath);
+        const projectExists = fs4.existsSync(project.absolutePath);
         if (!projectExists) {
           log.warn(`Projektpfad existiert nicht: ${project.absolutePath}`);
           log.info("Neue Session kann nicht gestartet werden.");
@@ -6109,7 +6130,7 @@ import { Command as Command13 } from "commander";
 import ora11 from "ora";
 
 // src/services/data/tags.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as path4 from "path";
 import * as os3 from "os";
 function getTagsPath() {
@@ -6117,11 +6138,11 @@ function getTagsPath() {
 }
 function loadTagsData() {
   const filepath = getTagsPath();
-  if (!fs4.existsSync(filepath)) {
+  if (!fs5.existsSync(filepath)) {
     return { sessions: {}, tagMeta: {} };
   }
   try {
-    const content = fs4.readFileSync(filepath, "utf-8");
+    const content = fs5.readFileSync(filepath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { sessions: {}, tagMeta: {} };
@@ -6130,10 +6151,10 @@ function loadTagsData() {
 function saveTagsData(data) {
   const filepath = getTagsPath();
   const dir = path4.dirname(filepath);
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
-  fs4.writeFileSync(filepath, JSON.stringify(data, null, 2));
+  fs5.writeFileSync(filepath, JSON.stringify(data, null, 2));
 }
 function addTagToSession(sessionId, tag) {
   const data = loadTagsData();
@@ -6389,8 +6410,8 @@ ${colors.dim("Beispiele:")}
 }));
 async function checkProjectExists(path15) {
   try {
-    const fs15 = await import("fs");
-    return fs15.existsSync(path15);
+    const fs16 = await import("fs");
+    return fs16.existsSync(path15);
   } catch {
     return false;
   }
@@ -6398,7 +6419,8 @@ async function checkProjectExists(path15) {
 sessionsCommand.command("push").description("Sessions in Cloud sichern").option("-p, --project <pfad>", "Nur Sessions eines Projekts").action(async (options) => {
   const { api: api2 } = await import("./client-H3JXPT5B.js");
   const { isAuthenticated: isAuthenticated2 } = await import("./config-FGMZONWV.js");
-  const { getProjectConfig: getProjectConfig2 } = await import("./config-D6M6LI6U.js");
+  const { getProjectConfig: getProjectConfig2, getAnalyticsConfig: getAnalyticsConfig2 } = await import("./config-D6M6LI6U.js");
+  const { createAnalyticsService } = await import("./analytics-6WNUPA56.js");
   if (!isAuthenticated2()) {
     log.errorWithSuggestion(Errors.NOT_AUTHENTICATED());
     return;
@@ -6426,15 +6448,24 @@ sessionsCommand.command("push").description("Sessions in Cloud sichern").option(
     if (!config.projectId) {
       continue;
     }
+    const analyticsConfig = getAnalyticsConfig2(project.absolutePath);
+    const analyticsService = createAnalyticsService(project.absolutePath, analyticsConfig);
     for (const session of project.sessions) {
       try {
+        const sessionAnalytics = analyticsService.getSessionAnalytics(session.sessionId);
         await api2.syncSession({
           sessionId: session.sessionId,
           projectId: config.projectId,
           summary: session.firstPrompt,
           messageCount: session.messageCount,
           firstPrompt: session.firstPrompt,
-          gitBranch: session.gitBranch
+          gitBranch: session.gitBranch,
+          // Include analytics data if available
+          tokenCount: sessionAnalytics ? sessionAnalytics.inputTokens + sessionAnalytics.outputTokens : void 0,
+          inputTokens: sessionAnalytics?.inputTokens,
+          outputTokens: sessionAnalytics?.outputTokens,
+          durationMinutes: sessionAnalytics?.duration,
+          toolsUsed: sessionAnalytics?.toolsUsed
         });
         syncedCount++;
       } catch {
@@ -6504,7 +6535,8 @@ sessionsCommand.command("pull").description("Sessions aus Cloud laden").option("
 sessionsCommand.command("sync").description("Sessions mit Cloud synchronisieren").option("-p, --project <pfad>", "Nur Sessions eines Projekts").action(async (options) => {
   const { api: api2 } = await import("./client-H3JXPT5B.js");
   const { isAuthenticated: isAuthenticated2 } = await import("./config-FGMZONWV.js");
-  const { getProjectConfig: getProjectConfig2 } = await import("./config-D6M6LI6U.js");
+  const { getProjectConfig: getProjectConfig2, getAnalyticsConfig: getAnalyticsConfig2 } = await import("./config-D6M6LI6U.js");
+  const { createAnalyticsService } = await import("./analytics-6WNUPA56.js");
   if (!isAuthenticated2()) {
     log.errorWithSuggestion(Errors.NOT_AUTHENTICATED());
     return;
@@ -6524,15 +6556,24 @@ sessionsCommand.command("sync").description("Sessions mit Cloud synchronisieren"
   for (const project of projects.filter((p) => p.sessions.length > 0)) {
     const config = getProjectConfig2(project.absolutePath);
     if (!config.projectId) continue;
+    const analyticsConfig = getAnalyticsConfig2(project.absolutePath);
+    const analyticsService = createAnalyticsService(project.absolutePath, analyticsConfig);
     for (const session of project.sessions) {
       try {
+        const sessionAnalytics = analyticsService.getSessionAnalytics(session.sessionId);
         await api2.syncSession({
           sessionId: session.sessionId,
           projectId: config.projectId,
           summary: session.firstPrompt,
           messageCount: session.messageCount,
           firstPrompt: session.firstPrompt,
-          gitBranch: session.gitBranch
+          gitBranch: session.gitBranch,
+          // Include analytics data if available
+          tokenCount: sessionAnalytics ? sessionAnalytics.inputTokens + sessionAnalytics.outputTokens : void 0,
+          inputTokens: sessionAnalytics?.inputTokens,
+          outputTokens: sessionAnalytics?.outputTokens,
+          durationMinutes: sessionAnalytics?.duration,
+          toolsUsed: sessionAnalytics?.toolsUsed
         });
         pushedCount++;
       } catch {
@@ -7169,7 +7210,7 @@ sessionCommand.command("config").description("Sandbox-Konfiguration verwalten").
 // src/commands/github/github-cmd.ts
 import { Command as Command15 } from "commander";
 import { spawn as spawn6, spawnSync as spawnSync5 } from "child_process";
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path5 from "path";
 import inquirer6 from "inquirer";
 var githubCommand = new Command15("github").description("GitHub Integration verwalten").action(() => {
@@ -7596,18 +7637,18 @@ githubCommand.command("git-hook").description("Git Hooks f\xFCr Branch-Session I
   const hooksDir = path5.join(gitDir, "hooks");
   const hookFile = path5.join(hooksDir, "post-checkout");
   if (options.uninstall) {
-    if (fs5.existsSync(hookFile)) {
-      const content = fs5.readFileSync(hookFile, "utf-8");
+    if (fs6.existsSync(hookFile)) {
+      const content = fs6.readFileSync(hookFile, "utf-8");
       if (content.includes("shiva hook branch-switch")) {
         const lines = content.split("\n");
         const filtered = lines.filter(
           (line) => !line.includes("shiva hook branch-switch") && !line.includes("# SHIVA Code")
         );
         if (filtered.filter((l) => l.trim() && !l.startsWith("#!")).length === 0) {
-          fs5.unlinkSync(hookFile);
+          fs6.unlinkSync(hookFile);
           log.success("Git Hook entfernt");
         } else {
-          fs5.writeFileSync(hookFile, filtered.join("\n"), "utf-8");
+          fs6.writeFileSync(hookFile, filtered.join("\n"), "utf-8");
           log.success("SHIVA aus Git Hook entfernt");
         }
       } else {
@@ -7622,12 +7663,12 @@ githubCommand.command("git-hook").description("Git Hooks f\xFCr Branch-Session I
   console.log(colors.orange.bold("SHIVA Code - Git Hook installieren"));
   console.log(colors.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   log.newline();
-  if (!fs5.existsSync(hooksDir)) {
-    fs5.mkdirSync(hooksDir, { recursive: true });
+  if (!fs6.existsSync(hooksDir)) {
+    fs6.mkdirSync(hooksDir, { recursive: true });
   }
   let existingContent = "";
-  if (fs5.existsSync(hookFile)) {
-    existingContent = fs5.readFileSync(hookFile, "utf-8");
+  if (fs6.existsSync(hookFile)) {
+    existingContent = fs6.readFileSync(hookFile, "utf-8");
     if (existingContent.includes("shiva hook branch-switch")) {
       log.warn("SHIVA Hook ist bereits installiert");
       log.info("Zum Entfernen: shiva github git-hook --uninstall");
@@ -7639,15 +7680,15 @@ githubCommand.command("git-hook").description("Git Hooks f\xFCr Branch-Session I
 shiva hook branch-switch "$1" "$2" --quiet 2>/dev/null || true
 `;
   if (existingContent) {
-    fs5.writeFileSync(hookFile, existingContent + shivaHookCode, "utf-8");
+    fs6.writeFileSync(hookFile, existingContent + shivaHookCode, "utf-8");
     log.success("SHIVA zu bestehendem Hook hinzugef\xFCgt");
   } else {
     const newHook = `#!/bin/bash
 ${shivaHookCode}`;
-    fs5.writeFileSync(hookFile, newHook, "utf-8");
+    fs6.writeFileSync(hookFile, newHook, "utf-8");
     log.success("Git Hook erstellt");
   }
-  fs5.chmodSync(hookFile, "755");
+  fs6.chmodSync(hookFile, "755");
   log.newline();
   log.info("Der Hook zeigt beim Branch-Wechsel an, ob eine Session existiert.");
   log.newline();
@@ -10159,7 +10200,7 @@ securityCommand.addCommand(devicesCommand);
 import { Command as Command20 } from "commander";
 import inquirer8 from "inquirer";
 import ora15 from "ora";
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path6 from "path";
 var SECURE_FILE_MODE = 384;
 var secretsCommand = new Command20("secrets").description(t("commands.secrets.description")).addHelpText("after", `
@@ -10409,7 +10450,7 @@ secretsCommand.command("env").description("Secrets als .env Format ausgeben").op
     spinner.stop();
     const envContent = Object.entries(secrets).map(([key, value]) => `${key}="${value}"`).join("\n");
     if (options.output) {
-      fs6.writeFileSync(options.output, envContent + "\n", { mode: SECURE_FILE_MODE });
+      fs7.writeFileSync(options.output, envContent + "\n", { mode: SECURE_FILE_MODE });
       log.success(`Secrets in ${options.output} geschrieben`);
       log.warn("Diese Datei enth\xE4lt sensible Daten!");
       log.dim(`Datei-Berechtigungen auf ${SECURE_FILE_MODE.toString(8)} gesetzt`);
@@ -10430,11 +10471,11 @@ secretsCommand.command("import").description(".env Datei in Vault importieren").
     return;
   }
   const filePath = path6.resolve(file);
-  if (!fs6.existsSync(filePath)) {
+  if (!fs7.existsSync(filePath)) {
     log.errorWithSuggestion(Errors.FILE_NOT_FOUND(file));
     return;
   }
-  const content = fs6.readFileSync(filePath, "utf-8");
+  const content = fs7.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const secrets = [];
   for (const line of lines) {
@@ -10539,7 +10580,7 @@ secretsCommand.command("export").description("Secrets exportieren").option("-p,
       }).join("\n");
     }
     if (options.output) {
-      fs6.writeFileSync(options.output, output + "\n", { mode: SECURE_FILE_MODE });
+      fs7.writeFileSync(options.output, output + "\n", { mode: SECURE_FILE_MODE });
       log.success(`Secrets in ${options.output} geschrieben`);
       log.warn("Diese Datei enth\xE4lt sensible Daten!");
       log.dim(`Datei-Berechtigungen auf ${SECURE_FILE_MODE.toString(8)} gesetzt`);
@@ -10734,19 +10775,19 @@ import { Command as Command22 } from "commander";
 import ora16 from "ora";
 
 // src/services/data/memory.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path7 from "path";
 import * as os4 from "os";
 function findAllClaudeMdFiles() {
   const results = [];
   const sessionsPath = path7.join(os4.homedir(), ".claude", "projects");
-  if (fs7.existsSync(sessionsPath)) {
-    const dirs = fs7.readdirSync(sessionsPath);
+  if (fs8.existsSync(sessionsPath)) {
+    const dirs = fs8.readdirSync(sessionsPath);
     for (const dir of dirs) {
       const projectPath = decodeProjectPath(dir);
-      if (projectPath && fs7.existsSync(projectPath)) {
+      if (projectPath && fs8.existsSync(projectPath)) {
         const claudeMdPath = path7.join(projectPath, "CLAUDE.md");
-        if (fs7.existsSync(claudeMdPath)) {
+        if (fs8.existsSync(claudeMdPath)) {
           results.push({
             path: claudeMdPath,
             projectPath,
@@ -10768,7 +10809,7 @@ function decodeProjectPath(encoded) {
   while (i < parts.length) {
     const part = parts[i];
     const testPath = currentPath + "/" + part;
-    if (fs7.existsSync(testPath)) {
+    if (fs8.existsSync(testPath)) {
       currentPath = testPath;
       i++;
     } else {
@@ -10776,21 +10817,21 @@ function decodeProjectPath(encoded) {
       for (let j = i + 1; j < parts.length && j <= i + 5 && !found; j++) {
         const partsToJoin = parts.slice(i, j + 1);
         const hyphenPath = currentPath + "/" + partsToJoin.join("-");
-        if (fs7.existsSync(hyphenPath)) {
+        if (fs8.existsSync(hyphenPath)) {
           currentPath = hyphenPath;
           i = j + 1;
           found = true;
           break;
         }
         const dotPath = currentPath + "/" + partsToJoin.join(".");
-        if (fs7.existsSync(dotPath)) {
+        if (fs8.existsSync(dotPath)) {
           currentPath = dotPath;
           i = j + 1;
           found = true;
           break;
         }
         const underscorePath = currentPath + "/" + partsToJoin.join("_");
-        if (fs7.existsSync(underscorePath)) {
+        if (fs8.existsSync(underscorePath)) {
           currentPath = underscorePath;
           i = j + 1;
           found = true;
@@ -10810,7 +10851,7 @@ function getLocalMemories() {
   const claudeFiles = findAllClaudeMdFiles();
   for (const file of claudeFiles) {
     try {
-      const content = fs7.readFileSync(file.path, "utf-8");
+      const content = fs8.readFileSync(file.path, "utf-8");
       const parsed = parseClaudeMd(content);
       for (const memory of parsed.memories) {
         memories.push({
@@ -10937,15 +10978,15 @@ async function searchMemories(query, options = {}) {
 }
 function deleteLocalMemory(projectPath, key) {
   const claudeMdPath = path7.join(projectPath, "CLAUDE.md");
-  if (!fs7.existsSync(claudeMdPath)) {
+  if (!fs8.existsSync(claudeMdPath)) {
     return false;
   }
   try {
-    let content = fs7.readFileSync(claudeMdPath, "utf-8");
+    let content = fs8.readFileSync(claudeMdPath, "utf-8");
     const regex = new RegExp(`^- \\*\\*${escapeRegex(key)}\\*\\* \\([^)]+\\): .+$`, "gm");
     const newContent = content.replace(regex, "").replace(/\n\n\n+/g, "\n\n");
     if (newContent !== content) {
-      fs7.writeFileSync(claudeMdPath, newContent);
+      fs8.writeFileSync(claudeMdPath, newContent);
       return true;
     }
     return false;
@@ -10987,14 +11028,14 @@ async function deleteMemory(projectPath, key, options = {}) {
 async function deleteAllProjectMemories(projectPath) {
   const result = { local: 0, cloud: 0 };
   const claudeMdPath = path7.join(projectPath, "CLAUDE.md");
-  if (fs7.existsSync(claudeMdPath)) {
+  if (fs8.existsSync(claudeMdPath)) {
     try {
-      let content = fs7.readFileSync(claudeMdPath, "utf-8");
+      let content = fs8.readFileSync(claudeMdPath, "utf-8");
       const parsed = parseClaudeMd(content);
       result.local = parsed.memories.length;
       const regex = /^- \*\*.+\*\* \([^)]+\): .+$/gm;
       const newContent = content.replace(regex, "").replace(/\n\n\n+/g, "\n\n");
-      fs7.writeFileSync(claudeMdPath, newContent);
+      fs8.writeFileSync(claudeMdPath, newContent);
     } catch {
     }
   }
@@ -11026,8 +11067,8 @@ async function getContextPreview(projectPath) {
     secrets: [],
     totalSize: 0
   };
-  if (fs7.existsSync(claudeMdPath)) {
-    const content = fs7.readFileSync(claudeMdPath, "utf-8");
+  if (fs8.existsSync(claudeMdPath)) {
+    const content = fs8.readFileSync(claudeMdPath, "utf-8");
     preview.claudeMdContent = content;
     preview.totalSize += content.length;
     const parsed = parseClaudeMd(content);
@@ -11040,8 +11081,8 @@ async function getContextPreview(projectPath) {
   }
   const shivaDir = path7.join(projectPath, ".shiva");
   const contextPath = path7.join(shivaDir, "github-context.md");
-  if (fs7.existsSync(contextPath)) {
-    const content = fs7.readFileSync(contextPath, "utf-8");
+  if (fs8.existsSync(contextPath)) {
+    const content = fs8.readFileSync(contextPath, "utf-8");
     preview.githubContext = content;
     preview.totalSize += content.length;
   }
@@ -11387,12 +11428,12 @@ function truncate(str, maxLen) {
 // src/commands/memory/context.ts
 import { Command as Command24 } from "commander";
 import * as path9 from "path";
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import ora18 from "ora";
 var contextCommand = new Command24("context").description("Zeigt was in Claude injected w\xFCrde").option("-d, --dir <path>", "Projektverzeichnis").option("--github", "GitHub Context einschlie\xDFen").option("--secrets", "Secret-Keys anzeigen").option("--raw", "Rohe CLAUDE.md Ausgabe").option("--json", "JSON Ausgabe").option("-s, --size", "Nur Gr\xF6\xDFe anzeigen").action(async (options) => {
   const projectPath = options.dir ? path9.resolve(options.dir) : process.cwd();
   const projectName = path9.basename(projectPath);
-  if (!fs8.existsSync(projectPath)) {
+  if (!fs9.existsSync(projectPath)) {
     log.error(`Verzeichnis nicht gefunden: ${projectPath}`);
     return;
   }
@@ -11811,12 +11852,12 @@ tagsCommand.command("cloud").description("Memory-Tags aus Cloud laden").option("
 // src/commands/memory/export.ts
 import { Command as Command26 } from "commander";
 import * as path11 from "path";
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import ora19 from "ora";
 import inquirer12 from "inquirer";
 
 // src/services/session/export.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as path10 from "path";
 async function exportSession(sessionId, options = {}) {
   const projects = await getAllClaudeProjects();
@@ -11837,8 +11878,8 @@ async function exportSession(sessionId, options = {}) {
           encodeProjectPath(project.absolutePath),
           session.sessionId + ".jsonl"
         );
-        if (fs9.existsSync(transcriptPath)) {
-          exported.transcript = fs9.readFileSync(transcriptPath, "utf-8");
+        if (fs10.existsSync(transcriptPath)) {
+          exported.transcript = fs10.readFileSync(transcriptPath, "utf-8");
         }
       }
       if (options.includeConversation && options.includeTranscript) {
@@ -11847,8 +11888,8 @@ async function exportSession(sessionId, options = {}) {
           encodeProjectPath(project.absolutePath),
           session.sessionId + ".jsonl"
         );
-        if (fs9.existsSync(transcriptPath)) {
-          const content = fs9.readFileSync(transcriptPath, "utf-8");
+        if (fs10.existsSync(transcriptPath)) {
+          const content = fs10.readFileSync(transcriptPath, "utf-8");
           const lines = content.split("\n").filter((l) => l.trim());
           exported.conversation = lines.map((line) => {
             try {
@@ -11870,12 +11911,12 @@ async function exportSessionToFile(sessionId, outputPath, options = {}) {
     return false;
   }
   const content = JSON.stringify(exported, null, 2);
-  fs9.writeFileSync(outputPath, content, "utf-8");
+  fs10.writeFileSync(outputPath, content, "utf-8");
   return true;
 }
 async function exportSessions(sessionIds, outputDir, options = {}) {
-  if (!fs9.existsSync(outputDir)) {
-    fs9.mkdirSync(outputDir, { recursive: true });
+  if (!fs10.existsSync(outputDir)) {
+    fs10.mkdirSync(outputDir, { recursive: true });
   }
   let success = 0;
   let failed = 0;
@@ -11884,7 +11925,7 @@ async function exportSessions(sessionIds, outputDir, options = {}) {
     if (exported) {
       const filename = `${exported.projectName}-${sessionId.slice(0, 8)}.json`;
       const filepath = path10.join(outputDir, filename);
-      fs9.writeFileSync(filepath, JSON.stringify(exported, null, 2));
+      fs10.writeFileSync(filepath, JSON.stringify(exported, null, 2));
       success++;
     } else {
       failed++;
@@ -11905,7 +11946,7 @@ async function exportProjectSessions(projectPath, outputDir, options = {}) {
 }
 function createBackupArchive(outputPath, projectPaths) {
   const claudeDir = getClaudeProjectsPath();
-  if (!fs9.existsSync(claudeDir)) {
+  if (!fs10.existsSync(claudeDir)) {
     return false;
   }
   try {
@@ -11914,14 +11955,14 @@ function createBackupArchive(outputPath, projectPaths) {
       for (const p of projectPaths) {
         const encoded = encodeProjectPath(p);
         const fullPath = path10.join(claudeDir, encoded);
-        if (fs9.existsSync(fullPath)) {
+        if (fs10.existsSync(fullPath)) {
           includePaths.push(encoded);
         }
       }
     } else {
-      const entries = fs9.readdirSync(claudeDir);
+      const entries = fs10.readdirSync(claudeDir);
       includePaths = entries.filter((e) => {
-        const stat = fs9.statSync(path10.join(claudeDir, e));
+        const stat = fs10.statSync(path10.join(claudeDir, e));
         return stat.isDirectory();
       });
     }
@@ -11940,28 +11981,28 @@ async function importSession(data, targetProjectPath) {
     const projectPath = targetProjectPath || data.projectPath;
     const encodedPath = encodeProjectPath(projectPath);
     const sessionDir = path10.join(getClaudeProjectsPath(), encodedPath);
-    if (!fs9.existsSync(sessionDir)) {
-      fs9.mkdirSync(sessionDir, { recursive: true });
+    if (!fs10.existsSync(sessionDir)) {
+      fs10.mkdirSync(sessionDir, { recursive: true });
     }
     const sessionFile = path10.join(sessionDir, data.session.sessionId + ".jsonl");
-    if (fs9.existsSync(sessionFile)) {
+    if (fs10.existsSync(sessionFile)) {
       return {
         success: false,
         message: "Session already exists"
       };
     }
     if (data.transcript) {
-      fs9.writeFileSync(sessionFile, data.transcript, "utf-8");
+      fs10.writeFileSync(sessionFile, data.transcript, "utf-8");
     } else if (data.conversation) {
       const transcript = data.conversation.map((entry) => JSON.stringify(entry)).join("\n");
-      fs9.writeFileSync(sessionFile, transcript, "utf-8");
+      fs10.writeFileSync(sessionFile, transcript, "utf-8");
     } else {
       const minimalEntry = {
         type: "imported",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         originalSession: data.session
       };
-      fs9.writeFileSync(sessionFile, JSON.stringify(minimalEntry) + "\n");
+      fs10.writeFileSync(sessionFile, JSON.stringify(minimalEntry) + "\n");
     }
     if (data.tags && data.tags.length > 0) {
       const { addTagToSession: addTagToSession2 } = await import("./tags.js");
@@ -11984,13 +12025,13 @@ async function importSession(data, targetProjectPath) {
 }
 async function importSessionFromFile(filepath, targetProjectPath) {
   try {
-    if (!fs9.existsSync(filepath)) {
+    if (!fs10.existsSync(filepath)) {
       return {
         success: false,
         message: `File not found: ${filepath}`
       };
     }
-    const content = fs9.readFileSync(filepath, "utf-8");
+    const content = fs10.readFileSync(filepath, "utf-8");
     const data = JSON.parse(content);
     if (!data.version || !data.session || !data.session.sessionId) {
       return {
@@ -12007,10 +12048,10 @@ async function importSessionFromFile(filepath, targetProjectPath) {
   }
 }
 async function importSessionsFromDirectory(dirPath, targetProjectPath) {
-  if (!fs9.existsSync(dirPath)) {
+  if (!fs10.existsSync(dirPath)) {
     return { success: 0, failed: 0, results: [] };
   }
-  const files = fs9.readdirSync(dirPath).filter((f) => f.endsWith(".json"));
+  const files = fs10.readdirSync(dirPath).filter((f) => f.endsWith(".json"));
   const results = [];
   let success = 0;
   let failed = 0;
@@ -12027,13 +12068,13 @@ async function importSessionsFromDirectory(dirPath, targetProjectPath) {
   return { success, failed, results };
 }
 function restoreFromArchive(archivePath, targetDir) {
-  if (!fs9.existsSync(archivePath)) {
+  if (!fs10.existsSync(archivePath)) {
     return false;
   }
   try {
     const extractTo = targetDir || getClaudeProjectsPath();
-    if (!fs9.existsSync(extractTo)) {
-      fs9.mkdirSync(extractTo, { recursive: true });
+    if (!fs10.existsSync(extractTo)) {
+      fs10.mkdirSync(extractTo, { recursive: true });
     }
     const extractResult = tarExec(["-xzf", archivePath, "-C", extractTo]);
     if (!extractResult.success) {
@@ -12046,10 +12087,10 @@ function restoreFromArchive(archivePath, targetDir) {
 }
 function previewExportFile(filepath) {
   try {
-    if (!fs9.existsSync(filepath)) {
+    if (!fs10.existsSync(filepath)) {
       return null;
     }
-    const content = fs9.readFileSync(filepath, "utf-8");
+    const content = fs10.readFileSync(filepath, "utf-8");
     const data = JSON.parse(content);
     return {
       ...data,
@@ -12095,7 +12136,7 @@ var importCommand = new Command26("import").description("Sessions importieren").
   console.log(colors.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   log.newline();
   const absolutePath = path11.resolve(inputPath);
-  if (!fs10.existsSync(absolutePath)) {
+  if (!fs11.existsSync(absolutePath)) {
     log.error(`Datei nicht gefunden: ${absolutePath}`);
     return;
   }
@@ -12107,7 +12148,7 @@ var importCommand = new Command26("import").description("Sessions importieren").
     await handlePreview(absolutePath);
     return;
   }
-  const stat = fs10.statSync(absolutePath);
+  const stat = fs11.statSync(absolutePath);
   if (stat.isDirectory()) {
     await handleImportDirectory(absolutePath, options.project);
   } else {
@@ -12121,7 +12162,7 @@ async function handleBackup(outputPath) {
   const success = createBackupArchive(output);
   if (success) {
     spinner.succeed(`Backup erstellt: ${output}`);
-    const stat = fs10.statSync(output);
+    const stat = fs11.statSync(output);
     log.dim(`Gr\xF6\xDFe: ${(stat.size / 1024 / 1024).toFixed(2)} MB`);
   } else {
     spinner.fail("Backup fehlgeschlagen");
@@ -12352,7 +12393,7 @@ ${colors.dim("Beispiele:")}
 // src/commands/system/doctor.ts
 import { Command as Command28 } from "commander";
 import { execSync as execSync2 } from "child_process";
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as path12 from "path";
 import * as os5 from "os";
 function tryExec(command) {
@@ -12517,7 +12558,7 @@ function checkNpm() {
 function checkShivaConfig() {
   const configDir = path12.join(os5.homedir(), ".config", "shiva-code");
   const configFile = path12.join(configDir, "config.json");
-  if (!fs11.existsSync(configDir)) {
+  if (!fs12.existsSync(configDir)) {
     return {
       name: "SHIVA Config",
       status: "warn",
@@ -12525,7 +12566,7 @@ function checkShivaConfig() {
       hint: "Wird bei erster Nutzung erstellt"
     };
   }
-  if (!fs11.existsSync(configFile)) {
+  if (!fs12.existsSync(configFile)) {
     return {
       name: "SHIVA Config",
       status: "warn",
@@ -12541,7 +12582,7 @@ function checkShivaConfig() {
 }
 function checkClaudeProjects() {
   const claudeDir = path12.join(os5.homedir(), ".claude", "projects");
-  if (!fs11.existsSync(claudeDir)) {
+  if (!fs12.existsSync(claudeDir)) {
     return {
       name: "Claude Projects",
       status: "warn",
@@ -12550,8 +12591,8 @@ function checkClaudeProjects() {
     };
   }
   try {
-    const projects = fs11.readdirSync(claudeDir).filter(
-      (f) => fs11.statSync(path12.join(claudeDir, f)).isDirectory()
+    const projects = fs12.readdirSync(claudeDir).filter(
+      (f) => fs12.statSync(path12.join(claudeDir, f)).isDirectory()
     );
     return {
       name: "Claude Projects",
@@ -12679,7 +12720,7 @@ var doctorCommand = new Command28("doctor").description("System-Check f\xFCr SHI
 // src/commands/system/upgrade.ts
 import { Command as Command29 } from "commander";
 import { execSync as execSync3, spawn as spawn7 } from "child_process";
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as path13 from "path";
 import * as os6 from "os";
 import * as crypto from "crypto";
@@ -12693,7 +12734,7 @@ function detectInstallationType() {
   const execName = path13.basename(execPath).toLowerCase();
   if (execName === "shiva" || execName === "shiva.exe") {
     const possibleNodeModules = path13.resolve(path13.dirname(execPath), "../node_modules");
-    if (!fs12.existsSync(possibleNodeModules)) {
+    if (!fs13.existsSync(possibleNodeModules)) {
       return "native";
     }
   }
@@ -12733,8 +12774,8 @@ function getCurrentVersion() {
   ];
   for (const pkgPath of possiblePaths) {
     try {
-      if (fs12.existsSync(pkgPath)) {
-        const packageJson = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+      if (fs13.existsSync(pkgPath)) {
+        const packageJson = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
         if (packageJson.name === PACKAGE_NAME && packageJson.version) {
           return packageJson.version;
         }
@@ -12850,7 +12891,7 @@ async function downloadFile(url, dest) {
     throw new Error(`Download failed: ${response.status} ${response.statusText}`);
   }
   const buffer = await response.arrayBuffer();
-  fs12.writeFileSync(dest, Buffer.from(buffer));
+  fs13.writeFileSync(dest, Buffer.from(buffer));
 }
 async function verifyChecksum(filePath, checksumUrl) {
   try {
@@ -12860,7 +12901,7 @@ async function verifyChecksum(filePath, checksumUrl) {
       return true;
     }
     const expectedHash = (await response.text()).trim().split(" ")[0].toLowerCase();
-    const fileBuffer = fs12.readFileSync(filePath);
+    const fileBuffer = fs13.readFileSync(filePath);
     const actualHash = crypto.createHash("sha256").update(fileBuffer).digest("hex").toLowerCase();
     return expectedHash === actualHash;
   } catch {
@@ -12889,16 +12930,16 @@ async function updateNativeBinary(targetVersion) {
     const checksumValid = await verifyChecksum(tempBinary, checksumUrl);
     if (!checksumValid) {
       log.error("Checksum stimmt nicht \xFCberein! Update abgebrochen.");
-      fs12.unlinkSync(tempBinary);
+      fs13.unlinkSync(tempBinary);
       return false;
     }
     log.success("  Checksum OK");
     if (platformInfo.platform !== "windows") {
-      fs12.chmodSync(tempBinary, 493);
+      fs13.chmodSync(tempBinary, 493);
     }
     log.info("Erstelle Backup...");
-    if (fs12.existsSync(currentBinary)) {
-      fs12.copyFileSync(currentBinary, backupBinary);
+    if (fs13.existsSync(currentBinary)) {
+      fs13.copyFileSync(currentBinary, backupBinary);
     }
     log.info("Installiere neue Version...");
     if (platformInfo.platform === "windows") {
@@ -12910,30 +12951,30 @@ move /y "${tempBinary}" "${currentBinary}"
 del "${backupBinary}" 2>nul
 del "%~f0"
 `;
-      fs12.writeFileSync(updateScript, scriptContent);
+      fs13.writeFileSync(updateScript, scriptContent);
       spawn7("cmd", ["/c", updateScript], { detached: true, stdio: "ignore" }).unref();
       log.success("Update wird nach Beenden angewendet");
       log.info("Bitte starte SHIVA neu.");
     } else {
-      fs12.renameSync(tempBinary, currentBinary);
-      if (fs12.existsSync(backupBinary)) {
-        fs12.unlinkSync(backupBinary);
+      fs13.renameSync(tempBinary, currentBinary);
+      if (fs13.existsSync(backupBinary)) {
+        fs13.unlinkSync(backupBinary);
       }
     }
     return true;
   } catch (error) {
     log.error(`Update fehlgeschlagen: ${error instanceof Error ? error.message : String(error)}`);
-    if (fs12.existsSync(backupBinary) && fs12.existsSync(currentBinary)) {
+    if (fs13.existsSync(backupBinary) && fs13.existsSync(currentBinary)) {
       try {
-        fs12.copyFileSync(backupBinary, currentBinary);
+        fs13.copyFileSync(backupBinary, currentBinary);
         log.info("Backup wiederhergestellt");
       } catch {
         log.warn("Backup konnte nicht wiederhergestellt werden");
       }
     }
-    if (fs12.existsSync(tempBinary)) {
+    if (fs13.existsSync(tempBinary)) {
       try {
-        fs12.unlinkSync(tempBinary);
+        fs13.unlinkSync(tempBinary);
       } catch {
       }
     }
@@ -13355,7 +13396,7 @@ complete -F _shiva_completions shiva
 `;
 }
 async function installBashCompletion() {
-  const fs15 = await import("fs");
+  const fs16 = await import("fs");
   const os9 = await import("os");
   const path15 = await import("path");
   const bashrcPath = path15.join(os9.homedir(), ".bashrc");
@@ -13363,15 +13404,15 @@ async function installBashCompletion() {
   const marker = "# SHIVA Code Bash Completion";
   try {
     let bashrc = "";
-    if (fs15.existsSync(bashrcPath)) {
-      bashrc = fs15.readFileSync(bashrcPath, "utf-8");
+    if (fs16.existsSync(bashrcPath)) {
+      bashrc = fs16.readFileSync(bashrcPath, "utf-8");
     }
     if (bashrc.includes(marker)) {
       log.warn("Bash completion bereits installiert");
       log.info("Manuell entfernen und neu installieren falls n\xF6tig");
       return;
     }
-    fs15.appendFileSync(bashrcPath, "\n" + completionScript);
+    fs16.appendFileSync(bashrcPath, "\n" + completionScript);
     log.success("Bash completion installiert");
     log.info("Ausf\xFChren: source ~/.bashrc");
   } catch (error) {
@@ -13498,7 +13539,7 @@ compdef _shiva shiva
 `;
 }
 async function installZshCompletion() {
-  const fs15 = await import("fs");
+  const fs16 = await import("fs");
   const os9 = await import("os");
   const path15 = await import("path");
   const zshrcPath = path15.join(os9.homedir(), ".zshrc");
@@ -13506,15 +13547,15 @@ async function installZshCompletion() {
   const marker = "# SHIVA Code Zsh Completion";
   try {
     let zshrc = "";
-    if (fs15.existsSync(zshrcPath)) {
-      zshrc = fs15.readFileSync(zshrcPath, "utf-8");
+    if (fs16.existsSync(zshrcPath)) {
+      zshrc = fs16.readFileSync(zshrcPath, "utf-8");
     }
     if (zshrc.includes(marker)) {
       log.warn("Zsh completion bereits installiert");
       log.info("Manuell entfernen und neu installieren falls n\xF6tig");
       return;
     }
-    fs15.appendFileSync(zshrcPath, "\n" + completionScript);
+    fs16.appendFileSync(zshrcPath, "\n" + completionScript);
     log.success("Zsh completion installiert");
     log.info("Ausf\xFChren: source ~/.zshrc");
   } catch (error) {
@@ -13603,17 +13644,17 @@ complete -c shiva -n "__fish_seen_subcommand_from stats" -l json -d "JSON Output
 `;
 }
 async function installFishCompletion() {
-  const fs15 = await import("fs");
+  const fs16 = await import("fs");
   const os9 = await import("os");
   const path15 = await import("path");
   const fishCompletionsDir = path15.join(os9.homedir(), ".config", "fish", "completions");
   const fishCompletionPath = path15.join(fishCompletionsDir, "shiva.fish");
   const completionScript = generateFishCompletion();
   try {
-    if (!fs15.existsSync(fishCompletionsDir)) {
-      fs15.mkdirSync(fishCompletionsDir, { recursive: true });
+    if (!fs16.existsSync(fishCompletionsDir)) {
+      fs16.mkdirSync(fishCompletionsDir, { recursive: true });
     }
-    fs15.writeFileSync(fishCompletionPath, completionScript);
+    fs16.writeFileSync(fishCompletionPath, completionScript);
     log.success("Fish completion installiert");
     log.info("Wird automatisch beim n\xE4chsten Start geladen");
   } catch (error) {
@@ -14836,7 +14877,7 @@ accountCommand.command("delete").description(t("account.deleteDesc")).option("-f
 
 // src/commands/system/uninstall.ts
 import { Command as Command38 } from "commander";
-import { existsSync as existsSync23, rmSync as rmSync2, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync23, rmSync as rmSync3, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join14 } from "path";
 import inquirer15 from "inquirer";
@@ -14927,7 +14968,7 @@ var uninstallCommand = new Command38("uninstall").description(t("uninstall.descr
     const spinner = ora23(t("uninstall.removingConfig")).start();
     try {
       if (existsSync23(CONFIG_DIR)) {
-        rmSync2(CONFIG_DIR, { recursive: true, force: true });
+        rmSync3(CONFIG_DIR, { recursive: true, force: true });
       }
       spinner.succeed(t("uninstall.configRemoved"));
     } catch (error) {
@@ -15251,7 +15292,7 @@ dockerCommand.action(() => {
 
 // src/commands/advanced/workflow.ts
 import { Command as Command40 } from "commander";
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path14 from "path";
 import * as os7 from "os";
 import ora25 from "ora";
@@ -15416,11 +15457,11 @@ function getWorkflowsPath() {
 }
 function loadCustomWorkflows() {
   const filepath = getWorkflowsPath();
-  if (!fs13.existsSync(filepath)) {
+  if (!fs14.existsSync(filepath)) {
     return {};
   }
   try {
-    const content = fs13.readFileSync(filepath, "utf-8");
+    const content = fs14.readFileSync(filepath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -15429,18 +15470,18 @@ function loadCustomWorkflows() {
 function saveCustomWorkflow(name, workflow) {
   const filepath = getWorkflowsPath();
   const dir = path14.dirname(filepath);
-  if (!fs13.existsSync(dir)) {
-    fs13.mkdirSync(dir, { recursive: true });
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
   const workflows = loadCustomWorkflows();
   workflows[name] = workflow;
-  fs13.writeFileSync(filepath, JSON.stringify(workflows, null, 2));
+  fs14.writeFileSync(filepath, JSON.stringify(workflows, null, 2));
 }
 function deleteCustomWorkflow(name) {
   const filepath = getWorkflowsPath();
   const workflows = loadCustomWorkflows();
   delete workflows[name];
-  fs13.writeFileSync(filepath, JSON.stringify(workflows, null, 2));
+  fs14.writeFileSync(filepath, JSON.stringify(workflows, null, 2));
 }
 async function executeStep(step) {
   const spinner = ora25("Ausf\xFChren...").start();
@@ -16195,7 +16236,7 @@ hookCommand.command("scan-session").description("Session nach sensiblen Tokens s
   const { detectTokens: detectTokens2, redactTokens, maskToken: maskToken2 } = await import("./token-detection-K6KCIWAU.js");
   const { api: api2 } = await import("./client-H3JXPT5B.js");
   const { isAuthenticated: isAuthenticated2 } = await import("./config-FGMZONWV.js");
-  const { existsSync: existsSync27, readFileSync: readFileSync15, writeFileSync: writeFileSync13, readdirSync: readdirSync6, statSync: statSync7 } = await import("fs");
+  const { existsSync: existsSync27, readFileSync: readFileSync15, writeFileSync: writeFileSync13, readdirSync: readdirSync7, statSync: statSync8 } = await import("fs");
   const { join: join17 } = await import("path");
   const { homedir: homedir12 } = await import("os");
   const quiet = options.quiet;
@@ -16219,16 +16260,16 @@ hookCommand.command("scan-session").description("Session nach sensiblen Tokens s
     } else if (existsSync27(claudeProjectsPath)) {
       const oneHourAgo = Date.now() - 60 * 60 * 1e3;
       try {
-        const projects = readdirSync6(claudeProjectsPath);
+        const projects = readdirSync7(claudeProjectsPath);
         for (const project of projects) {
           const projectPath = join17(claudeProjectsPath, project);
-          const stat = statSync7(projectPath);
+          const stat = statSync8(projectPath);
           if (!stat.isDirectory()) continue;
-          const files = readdirSync6(projectPath);
+          const files = readdirSync7(projectPath);
           for (const file of files) {
             if (!file.endsWith(".jsonl")) continue;
             const filePath = join17(projectPath, file);
-            const fileStat = statSync7(filePath);
+            const fileStat = statSync8(filePath);
             if (fileStat.mtime.getTime() > oneHourAgo) {
               sessionFiles.push(filePath);
             }
@@ -16310,7 +16351,7 @@ hookCommand.command("scan-session").description("Session nach sensiblen Tokens s
 
 // src/commands/advanced/package.ts
 import { Command as Command42 } from "commander";
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import inquirer17 from "inquirer";
 import ora26 from "ora";
 var packageCommand = new Command42("package").description("Projekt-Gruppen (Packages) verwalten").action(() => {
@@ -16407,7 +16448,7 @@ packageCommand.command("show <name>").description("Package-Details anzeigen").ac
   if (pkg.projects.length > 0) {
     console.log("Projekte:");
     for (const projectPath of pkg.projects) {
-      const exists = fs14.existsSync(projectPath);
+      const exists = fs15.existsSync(projectPath);
       const icon = exists ? colors.green("\u2713") : colors.yellow("\u26A0");
       const name2 = getProjectName(projectPath);
       console.log(`  ${icon} ${name2}`);
@@ -16662,7 +16703,7 @@ function listPackages() {
     }
     const displayProjects = pkg.projects.slice(0, 3);
     for (const projectPath of displayProjects) {
-      const exists = fs14.existsSync(projectPath);
+      const exists = fs15.existsSync(projectPath);
       const icon = exists ? colors.dim("\u2514\u2500") : colors.yellow("\u2514\u2500");
       console.log(`  ${icon} ${getProjectName(projectPath)}`);
     }
@@ -17299,8 +17340,7 @@ async function showDashboard() {
           newSession: false
         }], detectTerminal());
         if (isInsideTmux()) {
-          await new Promise((resolve14) => setTimeout(resolve14, 100));
-          return;
+          await showDashboard();
         }
       }
       break;
@@ -17314,8 +17354,7 @@ async function showDashboard() {
       if (launches.length > 0) {
         await spawnProjects(launches, detectTerminal());
         if (isInsideTmux()) {
-          await new Promise((resolve14) => setTimeout(resolve14, 100));
-          return;
+          await showDashboard();
         }
       }
       break;