episoda 0.2.9 → 0.2.11

package/dist/daemon/daemon-process.js

@@ -0,0 +1,3721 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../core/dist/command-protocol.js
+var require_command_protocol = __commonJS({
+  "../core/dist/command-protocol.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// ../core/dist/git-validator.js
+var require_git_validator = __commonJS({
+  "../core/dist/git-validator.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.validateBranchName = validateBranchName;
+    exports2.validateCommitMessage = validateCommitMessage;
+    exports2.validateFilePaths = validateFilePaths;
+    exports2.sanitizeArgs = sanitizeArgs;
+    function validateBranchName(branchName) {
+      if (!branchName || branchName.trim().length === 0) {
+        return { valid: false, error: "UNKNOWN_ERROR" };
+      }
+      const invalidPatterns = [
+        /^\-/,
+        // Starts with -
+        /^\//,
+        // Starts with /
+        /\.\./,
+        // Contains ..
+        /@\{/,
+        // Contains @{
+        /\\/,
+        // Contains backslash
+        /\.lock$/,
+        // Ends with .lock
+        /\/$/,
+        // Ends with /
+        /\s/,
+        // Contains whitespace
+        /[\x00-\x1F\x7F]/,
+        // Contains control characters
+        /[\*\?\[\]~\^:]/
+        // Contains special characters
+      ];
+      for (const pattern of invalidPatterns) {
+        if (pattern.test(branchName)) {
+          return { valid: false, error: "UNKNOWN_ERROR" };
+        }
+      }
+      if (branchName === "@") {
+        return { valid: false, error: "UNKNOWN_ERROR" };
+      }
+      if (branchName.length > 200) {
+        return { valid: false, error: "UNKNOWN_ERROR" };
+      }
+      return { valid: true };
+    }
+    function validateCommitMessage(message) {
+      if (!message || message.trim().length === 0) {
+        return { valid: false, error: "UNKNOWN_ERROR" };
+      }
+      if (message.length > 1e4) {
+        return { valid: false, error: "UNKNOWN_ERROR" };
+      }
+      return { valid: true };
+    }
+    function validateFilePaths(files) {
+      if (!files || files.length === 0) {
+        return { valid: true };
+      }
+      for (const file of files) {
+        if (file.includes("\0")) {
+          return { valid: false, error: "UNKNOWN_ERROR" };
+        }
+        if (/[\x00-\x1F\x7F]/.test(file)) {
+          return { valid: false, error: "UNKNOWN_ERROR" };
+        }
+        if (file.trim().length === 0) {
+          return { valid: false, error: "UNKNOWN_ERROR" };
+        }
+      }
+      return { valid: true };
+    }
+    function sanitizeArgs(args) {
+      return args.map((arg) => {
+        return arg.replace(/\0/g, "");
+      });
+    }
+  }
+});
+
+// ../core/dist/git-parser.js
+var require_git_parser = __commonJS({
+  "../core/dist/git-parser.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.parseGitStatus = parseGitStatus;
+    exports2.parseMergeConflicts = parseMergeConflicts;
+    exports2.parseGitError = parseGitError;
+    exports2.extractBranchName = extractBranchName;
+    exports2.isDetachedHead = isDetachedHead;
+    exports2.parseRemoteTracking = parseRemoteTracking;
+    function parseGitStatus(output) {
+      const lines = output.split("\n");
+      const uncommittedFiles = [];
+      let currentBranch;
+      for (const line of lines) {
+        if (line.startsWith("## ")) {
+          const branchInfo = line.substring(3);
+          const branchMatch = branchInfo.match(/^([^\s.]+)/);
+          if (branchMatch && branchMatch[1]) {
+            currentBranch = branchMatch[1] === "HEAD" ? "HEAD (detached)" : branchMatch[1];
+          }
+          continue;
+        }
+        if (line.length >= 3) {
+          const status = line.substring(0, 2);
+          const filePath = line.substring(3).trim();
+          if (status.trim().length > 0 && filePath.length > 0) {
+            uncommittedFiles.push(filePath);
+          }
+        }
+      }
+      const isClean = uncommittedFiles.length === 0;
+      return { uncommittedFiles, isClean, currentBranch };
+    }
+    function parseMergeConflicts(output) {
+      const lines = output.split("\n");
+      const conflictingFiles = [];
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("CONFLICT")) {
+          const match = trimmed.match(/CONFLICT.*in (.+)$/);
+          if (match && match[1]) {
+            conflictingFiles.push(match[1]);
+          }
+        }
+        if (trimmed.startsWith("UU ")) {
+          conflictingFiles.push(trimmed.substring(3).trim());
+        }
+      }
+      return conflictingFiles;
+    }
+    function parseGitError(stderr, stdout, exitCode) {
+      const combinedOutput = `${stderr}
+${stdout}`.toLowerCase();
+      if (combinedOutput.includes("git: command not found") || combinedOutput.includes("'git' is not recognized")) {
+        return "GIT_NOT_INSTALLED";
+      }
+      if (combinedOutput.includes("not a git repository") || combinedOutput.includes("not a git repo")) {
+        return "NOT_GIT_REPO";
+      }
+      if (combinedOutput.includes("conflict") || combinedOutput.includes("merge conflict") || exitCode === 1 && combinedOutput.includes("automatic merge failed")) {
+        return "MERGE_CONFLICT";
+      }
+      if (combinedOutput.includes("please commit your changes") || combinedOutput.includes("would be overwritten") || combinedOutput.includes("cannot checkout") && combinedOutput.includes("files would be overwritten")) {
+        return "UNCOMMITTED_CHANGES";
+      }
+      if (combinedOutput.includes("authentication failed") || combinedOutput.includes("could not read username") || combinedOutput.includes("permission denied") || combinedOutput.includes("could not read password") || combinedOutput.includes("fatal: authentication failed")) {
+        return "AUTH_FAILURE";
+      }
+      if (combinedOutput.includes("could not resolve host") || combinedOutput.includes("failed to connect") || combinedOutput.includes("network is unreachable") || combinedOutput.includes("connection timed out") || combinedOutput.includes("could not read from remote")) {
+        return "NETWORK_ERROR";
+      }
+      if (combinedOutput.includes("did not match any file") || combinedOutput.includes("branch") && combinedOutput.includes("not found") || combinedOutput.includes("pathspec") && combinedOutput.includes("did not match")) {
+        return "BRANCH_NOT_FOUND";
+      }
+      if (combinedOutput.includes("already exists") || combinedOutput.includes("a branch named") && combinedOutput.includes("already exists")) {
+        return "BRANCH_ALREADY_EXISTS";
+      }
+      if (combinedOutput.includes("push rejected") || combinedOutput.includes("failed to push") || combinedOutput.includes("rejected") && combinedOutput.includes("non-fast-forward") || combinedOutput.includes("updates were rejected")) {
+        return "PUSH_REJECTED";
+      }
+      if (exitCode === 124 || exitCode === 143) {
+        return "COMMAND_TIMEOUT";
+      }
+      return "UNKNOWN_ERROR";
+    }
+    function extractBranchName(output) {
+      const lines = output.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        let match = trimmed.match(/Switched to (?:a new )?branch '(.+)'/);
+        if (match && match[1]) {
+          return match[1];
+        }
+        match = trimmed.match(/On branch (.+)/);
+        if (match && match[1]) {
+          return match[1];
+        }
+      }
+      return void 0;
+    }
+    function isDetachedHead(output) {
+      return output.toLowerCase().includes("head detached") || output.toLowerCase().includes("you are in 'detached head' state");
+    }
+    function parseRemoteTracking(output) {
+      const lines = output.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        const match = trimmed.match(/set up to track remote branch '(.+?)'(?: from '(.+?)')?/);
+        if (match) {
+          return {
+            hasUpstream: true,
+            remoteBranch: match[1],
+            remote: match[2] || "origin"
+          };
+        }
+        const upstreamMatch = trimmed.match(/(?:up to date with|ahead of|behind) '(.+?)\/(.+?)'/);
+        if (upstreamMatch) {
+          return {
+            hasUpstream: true,
+            remote: upstreamMatch[1],
+            remoteBranch: upstreamMatch[2]
+          };
+        }
+      }
+      return { hasUpstream: false };
+    }
+  }
+});
+
+// ../core/dist/git-executor.js
+var require_git_executor = __commonJS({
+  "../core/dist/git-executor.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.GitExecutor = void 0;
+    var child_process_1 = require("child_process");
+    var util_1 = require("util");
+    var git_validator_1 = require_git_validator();
+    var git_parser_1 = require_git_parser();
+    var execAsync = (0, util_1.promisify)(child_process_1.exec);
+    var GitExecutor2 = class {
+      /**
+       * Execute a git command
+       * @param command - The git command to execute
+       * @param options - Execution options (timeout, cwd, etc.)
+       * @returns Structured result with success/error details
+       */
+      async execute(command, options) {
+        try {
+          const gitInstalled = await this.validateGitInstalled();
+          if (!gitInstalled) {
+            return {
+              success: false,
+              error: "GIT_NOT_INSTALLED"
+            };
+          }
+          const cwd = options?.cwd || process.cwd();
+          const isGitRepo = await this.isGitRepository(cwd);
+          if (!isGitRepo) {
+            return {
+              success: false,
+              error: "NOT_GIT_REPO"
+            };
+          }
+          switch (command.action) {
+            case "checkout":
+              return await this.executeCheckout(command, cwd, options);
+            case "create_branch":
+              return await this.executeCreateBranch(command, cwd, options);
+            case "commit":
+              return await this.executeCommit(command, cwd, options);
+            case "push":
+              return await this.executePush(command, cwd, options);
+            case "status":
+              return await this.executeStatus(cwd, options);
+            case "pull":
+              return await this.executePull(command, cwd, options);
+            case "delete_branch":
+              return await this.executeDeleteBranch(command, cwd, options);
+            // EP597: Read operations for production local dev mode
+            case "branch_exists":
+              return await this.executeBranchExists(command, cwd, options);
+            case "branch_has_commits":
+              return await this.executeBranchHasCommits(command, cwd, options);
+            // EP598: Main branch check for production
+            case "main_branch_check":
+              return await this.executeMainBranchCheck(cwd, options);
+            // EP599: Get commits for branch
+            case "get_commits":
+              return await this.executeGetCommits(command, cwd, options);
+            // EP599: Advanced operations for move-to-module and discard-main-changes
+            case "stash":
+              return await this.executeStash(command, cwd, options);
+            case "reset":
+              return await this.executeReset(command, cwd, options);
+            case "merge":
+              return await this.executeMerge(command, cwd, options);
+            case "cherry_pick":
+              return await this.executeCherryPick(command, cwd, options);
+            case "clean":
+              return await this.executeClean(command, cwd, options);
+            case "add":
+              return await this.executeAdd(command, cwd, options);
+            case "fetch":
+              return await this.executeFetch(command, cwd, options);
+            // EP599-3: Composite operations
+            case "move_to_module":
+              return await this.executeMoveToModule(command, cwd, options);
+            case "discard_main_changes":
+              return await this.executeDiscardMainChanges(cwd, options);
+            // EP523: Branch sync operations
+            case "sync_status":
+              return await this.executeSyncStatus(command, cwd, options);
+            case "sync_main":
+              return await this.executeSyncMain(cwd, options);
+            case "rebase_branch":
+              return await this.executeRebaseBranch(command, cwd, options);
+            case "rebase_abort":
+              return await this.executeRebaseAbort(cwd, options);
+            case "rebase_continue":
+              return await this.executeRebaseContinue(cwd, options);
+            case "rebase_status":
+              return await this.executeRebaseStatus(cwd, options);
+            default:
+              return {
+                success: false,
+                error: "UNKNOWN_ERROR",
+                output: "Unknown command action"
+              };
+          }
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error instanceof Error ? error.message : "Unknown error occurred"
+          };
+        }
+      }
+      /**
+       * Execute checkout command
+       */
+      async executeCheckout(command, cwd, options) {
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+          return {
+            success: false,
+            error: validation.error || "UNKNOWN_ERROR"
+          };
+        }
+        const statusResult = await this.executeStatus(cwd, options);
+        if (statusResult.success && statusResult.details?.uncommittedFiles?.length) {
+          return {
+            success: false,
+            error: "UNCOMMITTED_CHANGES",
+            details: {
+              uncommittedFiles: statusResult.details.uncommittedFiles
+            }
+          };
+        }
+        const args = ["checkout"];
+        if (command.create) {
+          args.push("-b");
+        }
+        args.push(command.branch);
+        return await this.runGitCommand(args, cwd, options);
+      }
+      /**
+       * Execute create_branch command
+       */
+      async executeCreateBranch(command, cwd, options) {
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+          return {
+            success: false,
+            error: validation.error || "UNKNOWN_ERROR"
+          };
+        }
+        if (command.from) {
+          const fromValidation = (0, git_validator_1.validateBranchName)(command.from);
+          if (!fromValidation.valid) {
+            return {
+              success: false,
+              error: fromValidation.error || "UNKNOWN_ERROR"
+            };
+          }
+        }
+        const args = ["checkout", "-b", command.branch];
+        if (command.from) {
+          args.push(command.from);
+        }
+        return await this.runGitCommand(args, cwd, options);
+      }
+      /**
+       * Execute commit command
+       */
+      async executeCommit(command, cwd, options) {
+        const validation = (0, git_validator_1.validateCommitMessage)(command.message);
+        if (!validation.valid) {
+          return {
+            success: false,
+            error: validation.error || "UNKNOWN_ERROR"
+          };
+        }
+        if (command.files) {
+          const fileValidation = (0, git_validator_1.validateFilePaths)(command.files);
+          if (!fileValidation.valid) {
+            return {
+              success: false,
+              error: fileValidation.error || "UNKNOWN_ERROR"
+            };
+          }
+          for (const file of command.files) {
+            const addResult = await this.runGitCommand(["add", file], cwd, options);
+            if (!addResult.success) {
+              return addResult;
+            }
+          }
+        } else {
+          const addResult = await this.runGitCommand(["add", "-A"], cwd, options);
+          if (!addResult.success) {
+            return addResult;
+          }
+        }
+        const args = ["commit", "-m", command.message];
+        return await this.runGitCommand(args, cwd, options);
+      }
+      /**
+       * Execute push command
+       * EP769: Added force parameter for pushing rebased branches
+       */
+      async executePush(command, cwd, options) {
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+          return {
+            success: false,
+            error: validation.error || "UNKNOWN_ERROR"
+          };
+        }
+        const args = ["push"];
+        if (command.force) {
+          args.push("--force");
+        }
+        if (command.setUpstream) {
+          args.push("-u", "origin", command.branch);
+        } else {
+          args.push("origin", command.branch);
+        }
+        const env = { ...process.env };
+        if (options?.githubToken) {
+          env.GIT_ASKPASS = "echo";
+          env.GIT_USERNAME = "x-access-token";
+          env.GIT_PASSWORD = options.githubToken;
+        }
+        return await this.runGitCommand(args, cwd, { ...options, env });
+      }
+      /**
+       * Execute status command
+       */
+      async executeStatus(cwd, options) {
+        const result = await this.runGitCommand(["status", "--porcelain", "-b"], cwd, options);
+        if (result.success && result.output) {
+          const statusInfo = (0, git_parser_1.parseGitStatus)(result.output);
+          return {
+            success: true,
+            output: result.output,
+            details: {
+              uncommittedFiles: statusInfo.uncommittedFiles,
+              branchName: statusInfo.currentBranch
+            }
+          };
+        }
+        return result;
+      }
+      /**
+       * Execute pull command
+       */
+      async executePull(command, cwd, options) {
+        if (command.branch) {
+          const validation = (0, git_validator_1.validateBranchName)(command.branch);
+          if (!validation.valid) {
+            return {
+              success: false,
+              error: validation.error || "UNKNOWN_ERROR"
+            };
+          }
+        }
+        const statusResult = await this.executeStatus(cwd, options);
+        if (statusResult.success && statusResult.details?.uncommittedFiles?.length) {
+          return {
+            success: false,
+            error: "UNCOMMITTED_CHANGES",
+            details: {
+              uncommittedFiles: statusResult.details.uncommittedFiles
+            }
+          };
+        }
+        const args = ["pull"];
+        if (command.branch) {
+          args.push("origin", command.branch);
+        }
+        const result = await this.runGitCommand(args, cwd, options);
+        if (!result.success && result.output) {
+          const conflicts = (0, git_parser_1.parseMergeConflicts)(result.output);
+          if (conflicts.length > 0) {
+            return {
+              success: false,
+              error: "MERGE_CONFLICT",
+              output: result.output,
+              details: {
+                conflictingFiles: conflicts
+              }
+            };
+          }
+        }
+        return result;
+      }
+      /**
+       * Execute delete_branch command
+       */
+      async executeDeleteBranch(command, cwd, options) {
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+          return {
+            success: false,
+            error: validation.error || "UNKNOWN_ERROR"
+          };
+        }
+        const args = ["branch"];
+        args.push(command.force ? "-D" : "-d");
+        args.push(command.branch);
+        return await this.runGitCommand(args, cwd, options);
+      }
+      /**
+       * EP597: Execute branch_exists command
+       * Checks if a branch exists locally and/or remotely
+       */
+      async executeBranchExists(command, cwd, options) {
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+          return {
+            success: false,
+            error: validation.error || "UNKNOWN_ERROR"
+          };
+        }
+        try {
+          let isLocal = false;
+          let isRemote = false;
+          try {
+            const { stdout: localBranches } = await execAsync("git branch --list", { cwd, timeout: options?.timeout || 1e4 });
+            isLocal = localBranches.split("\n").some((line) => {
+              const branchName = line.replace(/^\*?\s*/, "").trim();
+              return branchName === command.branch;
+            });
+          } catch {
+          }
+          try {
+            const { stdout: remoteBranches } = await execAsync(`git ls-remote --heads origin ${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
+            isRemote = remoteBranches.trim().length > 0;
+          } catch {
+          }
+          const branchExists = isLocal || isRemote;
+          return {
+            success: true,
+            output: branchExists ? `Branch ${command.branch} exists` : `Branch ${command.branch} does not exist`,
+            details: {
+              branchName: command.branch,
+              branchExists,
+              isLocal,
+              isRemote
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to check branch existence"
+          };
+        }
+      }
+      /**
+       * EP597: Execute branch_has_commits command
+       * Checks if a branch has commits ahead of the base branch (default: main)
+       */
+      async executeBranchHasCommits(command, cwd, options) {
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+          return {
+            success: false,
+            error: validation.error || "UNKNOWN_ERROR"
+          };
+        }
+        const baseBranch = command.baseBranch || "main";
+        try {
+          const { stdout } = await execAsync(`git cherry origin/${baseBranch} ${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
+          const uniqueCommits = stdout.trim().split("\n").filter((line) => line.startsWith("+"));
+          const hasCommits = uniqueCommits.length > 0;
+          return {
+            success: true,
+            output: hasCommits ? `Branch ${command.branch} has ${uniqueCommits.length} commits ahead of ${baseBranch}` : `Branch ${command.branch} has no commits ahead of ${baseBranch}`,
+            details: {
+              branchName: command.branch,
+              hasCommits
+            }
+          };
+        } catch (error) {
+          try {
+            const { stdout } = await execAsync(`git rev-list --count origin/${baseBranch}..${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
+            const commitCount = parseInt(stdout.trim(), 10);
+            const hasCommits = commitCount > 0;
+            return {
+              success: true,
+              output: hasCommits ? `Branch ${command.branch} has ${commitCount} commits ahead of ${baseBranch}` : `Branch ${command.branch} has no commits ahead of ${baseBranch}`,
+              details: {
+                branchName: command.branch,
+                hasCommits
+              }
+            };
+          } catch {
+            return {
+              success: false,
+              error: "BRANCH_NOT_FOUND",
+              output: error.message || `Failed to check commits for branch ${command.branch}`
+            };
+          }
+        }
+      }
+      /**
+       * EP598: Execute main branch check - returns current branch, uncommitted files, and unpushed commits
+       */
+      async executeMainBranchCheck(cwd, options) {
+        try {
+          let currentBranch = "";
+          try {
+            const { stdout } = await execAsync("git branch --show-current", { cwd, timeout: options?.timeout || 1e4 });
+            currentBranch = stdout.trim();
+          } catch (error) {
+            return {
+              success: false,
+              error: "UNKNOWN_ERROR",
+              output: error.message || "Failed to get current branch"
+            };
+          }
+          let uncommittedFiles = [];
+          try {
+            const { stdout } = await execAsync("git status --porcelain", { cwd, timeout: options?.timeout || 1e4 });
+            if (stdout) {
+              uncommittedFiles = stdout.split("\n").filter((line) => line.trim()).map((line) => {
+                const parts = line.trim().split(/\s+/);
+                return parts.slice(1).join(" ");
+              });
+            }
+          } catch {
+          }
+          let localCommits = [];
+          if (currentBranch === "main") {
+            try {
+              const { stdout } = await execAsync('git log origin/main..HEAD --format="%H|%s|%an"', { cwd, timeout: options?.timeout || 1e4 });
+              if (stdout) {
+                localCommits = stdout.split("\n").filter((line) => line.trim()).map((line) => {
+                  const [sha, message, author] = line.split("|");
+                  return {
+                    sha: sha ? sha.substring(0, 8) : "",
+                    message: message || "",
+                    author: author || ""
+                  };
+                });
+              }
+            } catch {
+            }
+          }
+          return {
+            success: true,
+            output: `Branch: ${currentBranch}, Uncommitted: ${uncommittedFiles.length}, Unpushed: ${localCommits.length}`,
+            details: {
+              currentBranch,
+              uncommittedFiles,
+              localCommits
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to check main branch"
+          };
+        }
+      }
+      /**
+       * EP599: Execute get_commits command
+       * Returns commits for a branch with pushed/unpushed status
+       */
+      async executeGetCommits(command, cwd, options) {
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+          return {
+            success: false,
+            error: validation.error || "UNKNOWN_ERROR"
+          };
+        }
+        const limit = command.limit || 10;
+        const baseBranch = command.baseBranch || "main";
+        try {
+          let stdout;
+          try {
+            const result = await execAsync(`git log ${baseBranch}.."${command.branch}" --pretty=format:"%H|%an|%ae|%aI|%s" -n ${limit} --`, { cwd, timeout: options?.timeout || 1e4 });
+            stdout = result.stdout;
+          } catch (error) {
+            try {
+              const result = await execAsync(`git log "${command.branch}" --pretty=format:"%H|%an|%ae|%aI|%s" -n ${limit} --`, { cwd, timeout: options?.timeout || 1e4 });
+              stdout = result.stdout;
+            } catch (branchError) {
+              return {
+                success: false,
+                error: "BRANCH_NOT_FOUND",
+                output: `Branch ${command.branch} not found locally`
+              };
+            }
+          }
+          if (!stdout.trim()) {
+            return {
+              success: true,
+              output: "No commits found",
+              details: {
+                commits: []
+              }
+            };
+          }
+          const commitLines = stdout.trim().split("\n");
+          let remoteShas = /* @__PURE__ */ new Set();
+          try {
+            const { stdout: remoteCommits } = await execAsync(`git log "origin/${command.branch}" --pretty=format:"%H" -n ${limit} --`, { cwd, timeout: options?.timeout || 1e4 });
+            remoteShas = new Set(remoteCommits.trim().split("\n").filter(Boolean));
+          } catch {
+          }
+          const commits = commitLines.map((line) => {
+            const [sha, authorName, authorEmail, date, ...messageParts] = line.split("|");
+            const message = messageParts.join("|");
+            const isPushed = remoteShas.has(sha);
+            return {
+              sha,
+              message,
+              authorName,
+              authorEmail,
+              date,
+              isPushed
+            };
+          });
+          return {
+            success: true,
+            output: `Found ${commits.length} commits`,
+            details: {
+              commits
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to get commits"
+          };
+        }
+      }
+      // ========================================
+      // EP599: Advanced operations for move-to-module and discard-main-changes
+      // ========================================
+      /**
+       * Execute git stash operations
+       */
+      async executeStash(command, cwd, options) {
+        try {
+          const args = ["stash"];
+          switch (command.operation) {
+            case "push":
+              args.push("push");
+              if (command.includeUntracked) {
+                args.push("--include-untracked");
+              }
+              if (command.message) {
+                args.push("-m", command.message);
+              }
+              break;
+            case "pop":
+              args.push("pop");
+              break;
+            case "drop":
+              args.push("drop");
+              break;
+            case "list":
+              args.push("list");
+              break;
+          }
+          return await this.runGitCommand(args, cwd, options);
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Stash operation failed"
+          };
+        }
+      }
+      /**
+       * Execute git reset
+       */
+      async executeReset(command, cwd, options) {
+        try {
+          const args = ["reset", `--${command.mode}`];
+          if (command.target) {
+            args.push(command.target);
+          }
+          return await this.runGitCommand(args, cwd, options);
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Reset failed"
+          };
+        }
+      }
+      /**
+       * Execute git merge
+       */
+      async executeMerge(command, cwd, options) {
+        try {
+          if (command.abort) {
+            return await this.runGitCommand(["merge", "--abort"], cwd, options);
+          }
+          const branchValidation = (0, git_validator_1.validateBranchName)(command.branch);
+          if (!branchValidation.valid) {
+            return {
+              success: false,
+              error: "BRANCH_NOT_FOUND",
+              output: branchValidation.error || "Invalid branch name"
+            };
+          }
+          const args = ["merge", command.branch];
+          if (command.strategy === "ours") {
+            args.push("--strategy=ours");
+          } else if (command.strategy === "theirs") {
+            args.push("--strategy-option=theirs");
+          }
+          if (command.noEdit) {
+            args.push("--no-edit");
+          }
+          const result = await this.runGitCommand(args, cwd, options);
+          if (!result.success && result.output?.includes("CONFLICT")) {
+            result.details = result.details || {};
+            result.details.mergeConflicts = true;
+          }
+          return result;
+        } catch (error) {
+          return {
+            success: false,
+            error: "MERGE_CONFLICT",
+            output: error.message || "Merge failed"
+          };
+        }
+      }
+      /**
+       * Execute git cherry-pick
+       */
+      async executeCherryPick(command, cwd, options) {
+        try {
+          if (command.abort) {
+            return await this.runGitCommand(["cherry-pick", "--abort"], cwd, options);
+          }
+          const result = await this.runGitCommand(["cherry-pick", command.sha], cwd, options);
+          if (!result.success && result.output?.includes("CONFLICT")) {
+            result.details = result.details || {};
+            result.details.cherryPickConflicts = true;
+          }
+          return result;
+        } catch (error) {
+          return {
+            success: false,
+            error: "MERGE_CONFLICT",
+            output: error.message || "Cherry-pick failed"
+          };
+        }
+      }
+      /**
+       * Execute git clean
+       */
+      async executeClean(command, cwd, options) {
+        try {
+          const args = ["clean"];
+          if (command.force) {
+            args.push("-f");
+          }
+          if (command.directories) {
+            args.push("-d");
+          }
+          return await this.runGitCommand(args, cwd, options);
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Clean failed"
+          };
+        }
+      }
+      /**
+       * Execute git add
+       */
+      async executeAdd(command, cwd, options) {
+        try {
+          const args = ["add"];
+          if (command.all) {
+            args.push("-A");
+          } else if (command.files && command.files.length > 0) {
+            const validation = (0, git_validator_1.validateFilePaths)(command.files);
+            if (!validation.valid) {
+              return {
+                success: false,
+                error: "UNKNOWN_ERROR",
+                output: validation.error || "Invalid file paths"
+              };
+            }
+            args.push(...command.files);
+          } else {
+            args.push("-A");
+          }
+          return await this.runGitCommand(args, cwd, options);
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Add failed"
+          };
+        }
+      }
+      /**
+       * Execute git fetch
+       */
+      async executeFetch(command, cwd, options) {
+        try {
+          const args = ["fetch"];
+          if (command.remote) {
+            args.push(command.remote);
+            if (command.branch) {
+              args.push(command.branch);
+            }
+          } else {
+            args.push("origin");
+          }
+          return await this.runGitCommand(args, cwd, options);
+        } catch (error) {
+          return {
+            success: false,
+            error: "NETWORK_ERROR",
+            output: error.message || "Fetch failed"
+          };
+        }
+      }
+      // ========================================
+      // EP599-3: Composite operations
+      // ========================================
+      /**
+       * Execute move_to_module - composite operation
+       * Moves commits/changes to a module branch with conflict handling
+       */
+      async executeMoveToModule(command, cwd, options) {
+        const { targetBranch, commitShas, conflictResolution } = command;
+        let hasStash = false;
+        const cherryPickedCommits = [];
+        try {
+          const { stdout: currentBranchOut } = await execAsync("git rev-parse --abbrev-ref HEAD", { cwd });
+          const currentBranch = currentBranchOut.trim();
+          const { stdout: statusOutput } = await execAsync("git status --porcelain", { cwd });
+          if (statusOutput.trim()) {
+            try {
+              await execAsync("git add -A", { cwd });
+              const { stdout: stashHash } = await execAsync('git stash create -m "episoda-move-to-module"', { cwd });
+              if (stashHash && stashHash.trim()) {
+                await execAsync(`git stash store -m "episoda-move-to-module" ${stashHash.trim()}`, { cwd });
+                await execAsync("git reset --hard HEAD", { cwd });
+                hasStash = true;
+              }
+            } catch (stashError) {
+            }
+          }
+          if (commitShas && commitShas.length > 0 && currentBranch !== "main" && currentBranch !== "master") {
+            await execAsync("git checkout main", { cwd });
+          }
+          let branchExists = false;
+          try {
+            await execAsync(`git rev-parse --verify ${targetBranch}`, { cwd });
+            branchExists = true;
+          } catch {
+            branchExists = false;
+          }
+          if (!branchExists) {
+            await execAsync(`git checkout -b ${targetBranch}`, { cwd });
+          } else {
+            await execAsync(`git checkout ${targetBranch}`, { cwd });
+            if (currentBranch === "main" || currentBranch === "master") {
+              try {
+                const mergeStrategy = conflictResolution === "ours" ? "--strategy=ours" : conflictResolution === "theirs" ? "--strategy-option=theirs" : "";
+                await execAsync(`git merge ${currentBranch} ${mergeStrategy} --no-edit`, { cwd });
+              } catch (mergeError) {
+                const { stdout: conflictStatus } = await execAsync("git status --porcelain", { cwd });
+                if (conflictStatus.includes("UU ") || conflictStatus.includes("AA ") || conflictStatus.includes("DD ")) {
+                  const { stdout: conflictFiles } = await execAsync("git diff --name-only --diff-filter=U", { cwd });
+                  const conflictedFiles = conflictFiles.trim().split("\n").filter(Boolean);
+                  if (conflictResolution) {
+                    for (const file of conflictedFiles) {
+                      await execAsync(`git checkout --${conflictResolution} "${file}"`, { cwd });
+                      await execAsync(`git add "${file}"`, { cwd });
+                    }
+                    await execAsync("git commit --no-edit", { cwd });
+                  } else {
+                    await execAsync("git merge --abort", { cwd });
+                    return {
+                      success: false,
+                      error: "MERGE_CONFLICT",
+                      output: "Merge conflicts detected",
+                      details: {
+                        hasConflicts: true,
+                        conflictedFiles,
+                        movedToBranch: targetBranch
+                      }
+                    };
+                  }
+                }
+              }
+            }
+          }
+          if (commitShas && commitShas.length > 0 && (currentBranch === "main" || currentBranch === "master")) {
+            for (const sha of commitShas) {
+              try {
+                const { stdout: logOutput } = await execAsync(`git log --format=%H ${targetBranch} | grep ${sha}`, { cwd }).catch(() => ({ stdout: "" }));
+                if (!logOutput.trim()) {
+                  await execAsync(`git cherry-pick ${sha}`, { cwd });
+                  cherryPickedCommits.push(sha);
+                }
+              } catch (err) {
+                await execAsync("git cherry-pick --abort", { cwd }).catch(() => {
+                });
+              }
+            }
+            await execAsync("git checkout main", { cwd });
+            await execAsync("git reset --hard origin/main", { cwd });
+            await execAsync(`git checkout ${targetBranch}`, { cwd });
+          }
+          if (hasStash) {
+            try {
+              await execAsync("git stash pop", { cwd });
+            } catch (stashError) {
+              const { stdout: conflictStatus } = await execAsync("git status --porcelain", { cwd });
+              if (conflictStatus.includes("UU ") || conflictStatus.includes("AA ")) {
+                if (conflictResolution) {
+                  const { stdout: conflictFiles } = await execAsync("git diff --name-only --diff-filter=U", { cwd });
+                  const conflictedFiles = conflictFiles.trim().split("\n").filter(Boolean);
+                  for (const file of conflictedFiles) {
+                    await execAsync(`git checkout --${conflictResolution} "${file}"`, { cwd });
+                    await execAsync(`git add "${file}"`, { cwd });
+                  }
+                }
+              }
+            }
+          }
+          return {
+            success: true,
+            output: `Successfully moved to branch ${targetBranch}`,
+            details: {
+              movedToBranch: targetBranch,
+              cherryPickedCommits,
+              currentBranch: targetBranch
+            }
+          };
+        } catch (error) {
+          if (hasStash) {
+            try {
+              const { stdout: stashList } = await execAsync("git stash list", { cwd });
+              if (stashList.includes("episoda-move-to-module")) {
+                await execAsync("git stash pop", { cwd });
+              }
+            } catch (e) {
+            }
+          }
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Move to module failed"
+          };
+        }
+      }
+      /**
+       * Execute discard_main_changes - composite operation
+       * Discards all uncommitted files and local commits on main branch
+       */
+      async executeDiscardMainChanges(cwd, options) {
+        try {
+          const { stdout: currentBranchOut } = await execAsync("git rev-parse --abbrev-ref HEAD", { cwd });
+          const branch = currentBranchOut.trim();
+          if (branch !== "main" && branch !== "master") {
+            return {
+              success: false,
+              error: "BRANCH_NOT_FOUND",
+              output: `Cannot discard changes - not on main branch. Current branch: ${branch}`
+            };
+          }
+          let discardedFiles = 0;
+          const { stdout: statusOutput } = await execAsync("git status --porcelain", { cwd });
+          if (statusOutput.trim()) {
+            try {
+              await execAsync("git stash --include-untracked", { cwd });
+              discardedFiles = statusOutput.trim().split("\n").length;
+            } catch (stashError) {
+            }
+          }
+          await execAsync("git fetch origin", { cwd });
+          await execAsync(`git reset --hard origin/${branch}`, { cwd });
+          try {
+            await execAsync("git clean -fd", { cwd });
+          } catch (cleanError) {
+          }
+          try {
+            await execAsync("git stash drop", { cwd });
+          } catch (dropError) {
+          }
+          return {
+            success: true,
+            output: `Successfully discarded all changes and reset to origin/${branch}`,
+            details: {
+              currentBranch: branch,
+              discardedFiles
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Discard main changes failed"
+          };
+        }
+      }
+      // ========================================
+      // EP523: Branch sync operations
+      // ========================================
+      /**
+       * EP523: Get sync status of a branch relative to main
+       * Returns how many commits behind/ahead the branch is
+       */
+      async executeSyncStatus(command, cwd, options) {
+        try {
+          const validation = (0, git_validator_1.validateBranchName)(command.branch);
+          if (!validation.valid) {
+            return {
+              success: false,
+              error: validation.error || "UNKNOWN_ERROR"
+            };
+          }
+          try {
+            await execAsync("git fetch origin", { cwd, timeout: options?.timeout || 3e4 });
+          } catch (fetchError) {
+            return {
+              success: false,
+              error: "NETWORK_ERROR",
+              output: "Unable to fetch from remote. Check your network connection."
+            };
+          }
+          let commitsBehind = 0;
+          let commitsAhead = 0;
+          try {
+            const { stdout: behindOutput } = await execAsync(`git rev-list --count ${command.branch}..origin/main`, { cwd, timeout: options?.timeout || 1e4 });
+            commitsBehind = parseInt(behindOutput.trim(), 10) || 0;
+          } catch {
+            commitsBehind = 0;
+          }
+          try {
+            const { stdout: aheadOutput } = await execAsync(`git rev-list --count origin/main..${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
+            commitsAhead = parseInt(aheadOutput.trim(), 10) || 0;
+          } catch {
+            commitsAhead = 0;
+          }
+          const isBehind = commitsBehind > 0;
+          const isAhead = commitsAhead > 0;
+          const needsSync = isBehind;
+          return {
+            success: true,
+            output: isBehind ? `Branch ${command.branch} is ${commitsBehind} commit(s) behind main` : `Branch ${command.branch} is up to date with main`,
+            details: {
+              branchName: command.branch,
+              commitsBehind,
+              commitsAhead,
+              isBehind,
+              isAhead,
+              needsSync
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to check sync status"
+          };
+        }
+      }
+      /**
+       * EP523: Sync local main branch with remote
+       * Used before creating new branches to ensure we branch from latest main
+       */
+      async executeSyncMain(cwd, options) {
+        try {
+          let currentBranch = "";
+          try {
+            const { stdout } = await execAsync("git branch --show-current", { cwd, timeout: 5e3 });
+            currentBranch = stdout.trim();
+          } catch {
+          }
+          try {
+            await execAsync("git fetch origin main", { cwd, timeout: options?.timeout || 3e4 });
+          } catch (fetchError) {
+            return {
+              success: false,
+              error: "NETWORK_ERROR",
+              output: "Unable to fetch from remote. Check your network connection."
+            };
+          }
+          const needsSwitch = currentBranch !== "main" && currentBranch !== "";
+          if (needsSwitch) {
+            const { stdout: statusOutput } = await execAsync("git status --porcelain", { cwd, timeout: 5e3 });
+            if (statusOutput.trim()) {
+              return {
+                success: false,
+                error: "UNCOMMITTED_CHANGES",
+                output: "Cannot sync main: you have uncommitted changes. Commit or stash them first.",
+                details: {
+                  uncommittedFiles: statusOutput.trim().split("\n").map((line) => line.slice(3))
+                }
+              };
+            }
+            await execAsync("git checkout main", { cwd, timeout: options?.timeout || 1e4 });
+          }
+          try {
+            await execAsync("git pull origin main", { cwd, timeout: options?.timeout || 3e4 });
+          } catch (pullError) {
+            if (pullError.message?.includes("CONFLICT") || pullError.stderr?.includes("CONFLICT")) {
+              await execAsync("git merge --abort", { cwd, timeout: 5e3 }).catch(() => {
+              });
+              return {
+                success: false,
+                error: "MERGE_CONFLICT",
+                output: "Conflict while syncing main. This is unexpected - main should not have local commits."
+              };
+            }
+            throw pullError;
+          }
+          if (needsSwitch && currentBranch) {
+            await execAsync(`git checkout "${currentBranch}"`, { cwd, timeout: options?.timeout || 1e4 });
+          }
+          return {
+            success: true,
+            output: "Successfully synced main with remote",
+            details: {
+              currentBranch: needsSwitch ? currentBranch : "main"
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to sync main"
+          };
+        }
+      }
+      /**
+       * EP523: Rebase a branch onto main
+       * Used when resuming work on a branch that's behind main
+       */
+      async executeRebaseBranch(command, cwd, options) {
+        try {
+          const validation = (0, git_validator_1.validateBranchName)(command.branch);
+          if (!validation.valid) {
+            return {
+              success: false,
+              error: validation.error || "UNKNOWN_ERROR"
+            };
+          }
+          const { stdout: statusOutput } = await execAsync("git status --porcelain", { cwd, timeout: 5e3 });
+          if (statusOutput.trim()) {
+            return {
+              success: false,
+              error: "UNCOMMITTED_CHANGES",
+              output: "Cannot rebase: you have uncommitted changes. Commit or stash them first.",
+              details: {
+                uncommittedFiles: statusOutput.trim().split("\n").map((line) => line.slice(3))
+              }
+            };
+          }
+          const { stdout: currentBranchOut } = await execAsync("git branch --show-current", { cwd, timeout: 5e3 });
+          const currentBranch = currentBranchOut.trim();
+          if (currentBranch !== command.branch) {
+            await execAsync(`git checkout "${command.branch}"`, { cwd, timeout: options?.timeout || 1e4 });
+          }
+          await execAsync("git fetch origin main", { cwd, timeout: options?.timeout || 3e4 });
+          try {
+            await execAsync("git rebase origin/main", { cwd, timeout: options?.timeout || 6e4 });
+          } catch (rebaseError) {
+            const errorOutput = (rebaseError.stderr || "") + (rebaseError.stdout || "");
+            if (errorOutput.includes("CONFLICT") || errorOutput.includes("could not apply")) {
+              let conflictFiles = [];
+              try {
+                const { stdout: conflictOutput } = await execAsync("git diff --name-only --diff-filter=U", { cwd, timeout: 5e3 });
+                conflictFiles = conflictOutput.trim().split("\n").filter(Boolean);
+              } catch {
+                try {
+                  const { stdout: statusOut } = await execAsync("git status --porcelain", { cwd, timeout: 5e3 });
+                  conflictFiles = statusOut.trim().split("\n").filter((line) => line.startsWith("UU ") || line.startsWith("AA ") || line.startsWith("DD ")).map((line) => line.slice(3));
+                } catch {
+                }
+              }
+              return {
+                success: false,
+                error: "REBASE_CONFLICT",
+                output: `Rebase conflict in ${conflictFiles.length} file(s). Resolve conflicts then use rebase_continue, or use rebase_abort to cancel.`,
+                details: {
+                  inRebase: true,
+                  rebaseConflicts: conflictFiles,
+                  hasConflicts: true,
+                  conflictedFiles: conflictFiles
+                }
+              };
+            }
+            throw rebaseError;
+          }
+          return {
+            success: true,
+            output: `Successfully rebased ${command.branch} onto main`,
+            details: {
+              branchName: command.branch,
+              inRebase: false
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Rebase failed"
+          };
+        }
+      }
+      /**
+       * EP523: Abort an in-progress rebase
+       * Returns to the state before rebase was started
+       */
+      async executeRebaseAbort(cwd, options) {
+        try {
+          await execAsync("git rebase --abort", { cwd, timeout: options?.timeout || 1e4 });
+          return {
+            success: true,
+            output: "Rebase aborted. Your branch has been restored to its previous state.",
+            details: {
+              inRebase: false
+            }
+          };
+        } catch (error) {
+          if (error.message?.includes("No rebase in progress") || error.stderr?.includes("No rebase in progress")) {
+            return {
+              success: true,
+              output: "No rebase in progress.",
+              details: {
+                inRebase: false
+              }
+            };
+          }
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to abort rebase"
+          };
+        }
+      }
+      /**
+       * EP523: Continue a paused rebase after conflicts are resolved
+       */
+      async executeRebaseContinue(cwd, options) {
+        try {
+          await execAsync("git add -A", { cwd, timeout: 5e3 });
+          await execAsync("git rebase --continue", { cwd, timeout: options?.timeout || 6e4 });
+          return {
+            success: true,
+            output: "Rebase continued successfully.",
+            details: {
+              inRebase: false
+            }
+          };
+        } catch (error) {
+          const errorOutput = (error.stderr || "") + (error.stdout || "");
+          if (errorOutput.includes("CONFLICT") || errorOutput.includes("could not apply")) {
+            let conflictFiles = [];
+            try {
+              const { stdout: conflictOutput } = await execAsync("git diff --name-only --diff-filter=U", { cwd, timeout: 5e3 });
+              conflictFiles = conflictOutput.trim().split("\n").filter(Boolean);
+            } catch {
+            }
+            return {
+              success: false,
+              error: "REBASE_CONFLICT",
+              output: "More conflicts encountered. Resolve them and try again.",
+              details: {
+                inRebase: true,
+                rebaseConflicts: conflictFiles,
+                hasConflicts: true,
+                conflictedFiles: conflictFiles
+              }
+            };
+          }
+          if (errorOutput.includes("No rebase in progress")) {
+            return {
+              success: true,
+              output: "No rebase in progress.",
+              details: {
+                inRebase: false
+              }
+            };
+          }
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to continue rebase"
+          };
+        }
+      }
+      /**
+       * EP523: Check if a rebase is currently in progress
+       */
+      async executeRebaseStatus(cwd, options) {
+        try {
+          let inRebase = false;
+          let rebaseConflicts = [];
+          try {
+            const { stdout: gitDir } = await execAsync("git rev-parse --git-dir", { cwd, timeout: 5e3 });
+            const gitDirPath = gitDir.trim();
+            const fs6 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const rebaseMergePath = `${gitDirPath}/rebase-merge`;
+            const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
+            try {
+              await fs6.access(rebaseMergePath);
+              inRebase = true;
+            } catch {
+              try {
+                await fs6.access(rebaseApplyPath);
+                inRebase = true;
+              } catch {
+                inRebase = false;
+              }
+            }
+          } catch {
+            try {
+              const { stdout: statusOutput } = await execAsync("git status", { cwd, timeout: 5e3 });
+              inRebase = statusOutput.includes("rebase in progress") || statusOutput.includes("interactive rebase in progress") || statusOutput.includes("You are currently rebasing");
+            } catch {
+              inRebase = false;
+            }
+          }
+          if (inRebase) {
+            try {
+              const { stdout: conflictOutput } = await execAsync("git diff --name-only --diff-filter=U", { cwd, timeout: 5e3 });
+              rebaseConflicts = conflictOutput.trim().split("\n").filter(Boolean);
+            } catch {
+            }
+          }
+          return {
+            success: true,
+            output: inRebase ? `Rebase in progress with ${rebaseConflicts.length} conflicting file(s)` : "No rebase in progress",
+            details: {
+              inRebase,
+              rebaseConflicts,
+              hasConflicts: rebaseConflicts.length > 0
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to check rebase status"
+          };
+        }
+      }
+      /**
+       * Run a git command and return structured result
+       */
+      async runGitCommand(args, cwd, options) {
+        try {
+          const sanitizedArgs = (0, git_validator_1.sanitizeArgs)(args);
+          const command = ["git", ...sanitizedArgs].join(" ");
+          const timeout = options?.timeout || 3e4;
+          const execOptions = {
+            cwd,
+            timeout,
+            env: options?.env || process.env,
+            maxBuffer: 1024 * 1024 * 10
+            // 10MB buffer
+          };
+          const { stdout, stderr } = await execAsync(command, execOptions);
+          const output = (stdout + stderr).trim();
+          const details = {};
+          const branchName = (0, git_parser_1.extractBranchName)(output);
+          if (branchName) {
+            details.branchName = branchName;
+          }
+          if ((0, git_parser_1.isDetachedHead)(output)) {
+            details.branchName = "HEAD (detached)";
+          }
+          return {
+            success: true,
+            output,
+            details: Object.keys(details).length > 0 ? details : void 0
+          };
+        } catch (error) {
+          const stderr = error.stderr || "";
+          const stdout = error.stdout || "";
+          const exitCode = error.code || 1;
+          const errorCode = (0, git_parser_1.parseGitError)(stderr, stdout, exitCode);
+          const details = {
+            exitCode
+          };
+          if (errorCode === "MERGE_CONFLICT") {
+            const conflicts = (0, git_parser_1.parseMergeConflicts)(stdout + stderr);
+            if (conflicts.length > 0) {
+              details.conflictingFiles = conflicts;
+            }
+          }
+          if (errorCode === "UNCOMMITTED_CHANGES") {
+            try {
+              const statusResult = await this.executeStatus(cwd, options);
+              if (statusResult.details?.uncommittedFiles) {
+                details.uncommittedFiles = statusResult.details.uncommittedFiles;
+              }
+            } catch {
+            }
+          }
+          return {
+            success: false,
+            error: errorCode,
+            output: (stdout + stderr).trim(),
+            details
+          };
+        }
+      }
+      /**
+       * Validate that git is installed
+       */
+      async validateGitInstalled() {
+        try {
+          await execAsync("git --version", { timeout: 5e3 });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Check if directory is a git repository
+       */
+      async isGitRepository(cwd) {
+        try {
+          await execAsync("git rev-parse --git-dir", { cwd, timeout: 5e3 });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Detect the git working directory (repository root)
+       * @returns Path to the git repository root
+       */
+      async detectWorkingDirectory(startPath) {
+        try {
+          const { stdout } = await execAsync("git rev-parse --show-toplevel", {
+            cwd: startPath || process.cwd(),
+            timeout: 5e3
+          });
+          return stdout.trim();
+        } catch {
+          return null;
+        }
+      }
+    };
+    exports2.GitExecutor = GitExecutor2;
+  }
+});
+
+// ../core/dist/version.js
+var require_version = __commonJS({
+  "../core/dist/version.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.VERSION = void 0;
+    var fs_1 = require("fs");
+    var path_1 = require("path");
+    var packageJsonPath = (0, path_1.join)(__dirname, "..", "package.json");
+    var packageJson2 = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"));
+    exports2.VERSION = packageJson2.version;
+  }
+});
+
+// ../core/dist/websocket-client.js
+var require_websocket_client = __commonJS({
+  "../core/dist/websocket-client.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.EpisodaClient = void 0;
+    var ws_1 = __importDefault(require("ws"));
+    var https_1 = __importDefault(require("https"));
+    var version_1 = require_version();
+    var ipv4Agent = new https_1.default.Agent({ family: 4 });
+    var INITIAL_RECONNECT_DELAY = 1e3;
+    var MAX_RECONNECT_DELAY = 6e4;
+    var IDLE_RECONNECT_DELAY = 6e5;
+    var MAX_RETRY_DURATION = 6 * 60 * 60 * 1e3;
+    var IDLE_THRESHOLD = 60 * 60 * 1e3;
+    var RAPID_CLOSE_THRESHOLD = 2e3;
+    var RAPID_CLOSE_BACKOFF = 3e4;
+    var CLIENT_HEARTBEAT_INTERVAL = 45e3;
+    var CLIENT_HEARTBEAT_TIMEOUT = 15e3;
+    var CONNECTION_TIMEOUT = 15e3;
+    var EpisodaClient2 = class {
+      constructor() {
+        this.eventHandlers = /* @__PURE__ */ new Map();
+        this.reconnectAttempts = 0;
+        this.url = "";
+        this.token = "";
+        this.isConnected = false;
+        this.isDisconnecting = false;
+        this.isGracefulShutdown = false;
+        this.lastCommandTime = Date.now();
+        this.isIntentionalDisconnect = false;
+        this.lastConnectAttemptTime = 0;
+      }
+      /**
+       * Connect to episoda.dev WebSocket gateway
+       * @param url - WebSocket URL (wss://episoda.dev/cli)
+       * @param token - OAuth access token
+       * @param machineId - Optional machine identifier for multi-machine support
+       * @param deviceInfo - Optional device information (hostname, OS, daemonPid)
+       */
+      async connect(url, token, machineId, deviceInfo) {
+        this.url = url;
+        this.token = token;
+        this.machineId = machineId;
+        this.hostname = deviceInfo?.hostname;
+        this.osPlatform = deviceInfo?.osPlatform;
+        this.osArch = deviceInfo?.osArch;
+        this.daemonPid = deviceInfo?.daemonPid;
+        this.isDisconnecting = false;
+        this.isGracefulShutdown = false;
+        this.isIntentionalDisconnect = false;
+        this.lastConnectAttemptTime = Date.now();
+        this.lastErrorCode = void 0;
+        return new Promise((resolve2, reject) => {
+          const connectionTimeout = setTimeout(() => {
+            if (this.ws) {
+              this.ws.terminate();
+            }
+            reject(new Error(`Connection timeout after ${CONNECTION_TIMEOUT / 1e3}s - server may be unreachable`));
+          }, CONNECTION_TIMEOUT);
+          try {
+            this.ws = new ws_1.default(url, { agent: ipv4Agent });
+            this.ws.on("open", () => {
+              clearTimeout(connectionTimeout);
+              console.log("[EpisodaClient] WebSocket connected");
+              this.isConnected = true;
+              this.reconnectAttempts = 0;
+              this.firstDisconnectTime = void 0;
+              this.lastCommandTime = Date.now();
+              this.send({
+                type: "auth",
+                token,
+                version: version_1.VERSION,
+                machineId,
+                hostname: this.hostname,
+                osPlatform: this.osPlatform,
+                osArch: this.osArch,
+                daemonPid: this.daemonPid
+              });
+              this.startHeartbeat();
+              resolve2();
+            });
+            this.ws.on("pong", () => {
+              if (this.heartbeatTimeoutTimer) {
+                clearTimeout(this.heartbeatTimeoutTimer);
+                this.heartbeatTimeoutTimer = void 0;
+              }
+            });
+            this.ws.on("message", (data) => {
+              try {
+                const message = JSON.parse(data.toString());
+                this.handleMessage(message);
+              } catch (error) {
+                console.error("[EpisodaClient] Failed to parse message:", error);
+              }
+            });
+            this.ws.on("ping", () => {
+              console.log("[EpisodaClient] Received ping from server");
+            });
+            this.ws.on("close", (code, reason) => {
+              console.log(`[EpisodaClient] WebSocket closed: ${code} ${reason.toString()}`);
+              this.isConnected = false;
+              const willReconnect = !this.isDisconnecting;
+              this.emit({
+                type: "disconnected",
+                code,
+                reason: reason.toString(),
+                willReconnect
+              });
+              if (willReconnect) {
+                this.scheduleReconnect();
+              }
+            });
+            this.ws.on("error", (error) => {
+              console.error("[EpisodaClient] WebSocket error:", error);
+              if (!this.isConnected) {
+                clearTimeout(connectionTimeout);
+                reject(error);
+              }
+            });
+          } catch (error) {
+            clearTimeout(connectionTimeout);
+            reject(error);
+          }
+        });
+      }
+      /**
+       * Disconnect from the server
+       * @param intentional - If true, prevents automatic reconnection (user-initiated disconnect)
+       */
+      async disconnect(intentional = true) {
+        this.isDisconnecting = true;
+        this.isIntentionalDisconnect = intentional;
+        if (this.reconnectTimeout) {
+          clearTimeout(this.reconnectTimeout);
+          this.reconnectTimeout = void 0;
+        }
+        if (this.heartbeatTimer) {
+          clearInterval(this.heartbeatTimer);
+          this.heartbeatTimer = void 0;
+        }
+        if (this.heartbeatTimeoutTimer) {
+          clearTimeout(this.heartbeatTimeoutTimer);
+          this.heartbeatTimeoutTimer = void 0;
+        }
+        if (this.ws) {
+          this.ws.close();
+          this.ws = void 0;
+        }
+        this.isConnected = false;
+      }
+      /**
+       * Register an event handler
+       * @param event - Event type ('command', 'ping', 'error', 'auth_success')
+       * @param handler - Handler function
+       */
+      on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+          this.eventHandlers.set(event, []);
+        }
+        this.eventHandlers.get(event).push(handler);
+      }
+      /**
+       * Send a message to the server
+       * @param message - Client message to send
+       */
+      async send(message) {
+        if (!this.ws || !this.isConnected) {
+          throw new Error("WebSocket not connected");
+        }
+        return new Promise((resolve2, reject) => {
+          this.ws.send(JSON.stringify(message), (error) => {
+            if (error) {
+              console.error("[EpisodaClient] Failed to send message:", error);
+              reject(error);
+            } else {
+              resolve2();
+            }
+          });
+        });
+      }
+      /**
+       * Get current connection status
+       */
+      getStatus() {
+        return {
+          connected: this.isConnected
+        };
+      }
+      /**
+       * EP605: Update last command time to reset idle detection
+       * Call this when a command is received/executed
+       */
+      updateActivity() {
+        this.lastCommandTime = Date.now();
+      }
+      /**
+       * EP701: Emit a client-side event to registered handlers
+       * Used for events like 'disconnected' that originate from the client, not server
+       */
+      emit(event) {
+        const handlers = this.eventHandlers.get(event.type) || [];
+        handlers.forEach((handler) => {
+          try {
+            handler(event);
+          } catch (error) {
+            console.error(`[EpisodaClient] Handler error for ${event.type}:`, error);
+          }
+        });
+      }
+      /**
+       * Handle incoming message from server
+       */
+      handleMessage(message) {
+        if (message.type === "shutdown") {
+          console.log("[EpisodaClient] Received graceful shutdown message from server");
+          this.isGracefulShutdown = true;
+        }
+        if (message.type === "error") {
+          const errorMessage = message;
+          this.lastErrorCode = errorMessage.code;
+          if (errorMessage.code === "RATE_LIMITED" || errorMessage.code === "TOO_SOON") {
+            const defaultRetry = errorMessage.code === "RATE_LIMITED" ? 60 : 5;
+            const retryAfterMs = (errorMessage.retryAfter || defaultRetry) * 1e3;
+            this.rateLimitBackoffUntil = Date.now() + retryAfterMs;
+            console.log(`[EpisodaClient] ${errorMessage.code}: will retry after ${retryAfterMs / 1e3}s`);
+          }
+        }
+        const handlers = this.eventHandlers.get(message.type) || [];
+        handlers.forEach((handler) => {
+          try {
+            handler(message);
+          } catch (error) {
+            console.error(`[EpisodaClient] Handler error for ${message.type}:`, error);
+          }
+        });
+      }
+      /**
+       * Schedule reconnection with exponential backoff and randomization
+       *
+       * EP605: Conservative reconnection with multiple safeguards:
+       * - 6-hour maximum retry duration to prevent indefinite retrying
+       * - Activity-based backoff (10 min delay if idle for 1+ hour)
+       * - No reconnection after intentional disconnect
+       * - Randomization to prevent thundering herd
+       *
+       * EP648: Additional protections against reconnection loops:
+       * - Rate limit awareness: respect server's RATE_LIMITED response
+       * - Rapid close detection: if connection closes within 2s, apply longer backoff
+       */
+      scheduleReconnect() {
+        if (this.isIntentionalDisconnect) {
+          console.log("[EpisodaClient] Intentional disconnect - not reconnecting");
+          return;
+        }
+        if (this.heartbeatTimer) {
+          clearInterval(this.heartbeatTimer);
+          this.heartbeatTimer = void 0;
+        }
+        if (this.heartbeatTimeoutTimer) {
+          clearTimeout(this.heartbeatTimeoutTimer);
+          this.heartbeatTimeoutTimer = void 0;
+        }
+        if (!this.firstDisconnectTime) {
+          this.firstDisconnectTime = Date.now();
+        }
+        const retryDuration = Date.now() - this.firstDisconnectTime;
+        if (retryDuration >= MAX_RETRY_DURATION) {
+          console.error(`[EpisodaClient] Maximum retry duration (6 hours) exceeded, giving up. Please restart the CLI.`);
+          return;
+        }
+        if (this.reconnectAttempts > 0 && this.reconnectAttempts % 10 === 0) {
+          const hoursRemaining = ((MAX_RETRY_DURATION - retryDuration) / (60 * 60 * 1e3)).toFixed(1);
+          console.log(`[EpisodaClient] Still attempting to reconnect (attempt ${this.reconnectAttempts}, ${hoursRemaining}h remaining)...`);
+        }
+        if (this.rateLimitBackoffUntil && Date.now() < this.rateLimitBackoffUntil) {
+          const waitTime = this.rateLimitBackoffUntil - Date.now();
+          console.log(`[EpisodaClient] Rate limited, waiting ${Math.round(waitTime / 1e3)}s before retry`);
+          this.reconnectAttempts++;
+          this.reconnectTimeout = setTimeout(() => {
+            this.rateLimitBackoffUntil = void 0;
+            this.scheduleReconnect();
+          }, waitTime);
+          return;
+        }
+        const timeSinceConnect = Date.now() - this.lastConnectAttemptTime;
+        const wasRapidClose = timeSinceConnect < RAPID_CLOSE_THRESHOLD && this.lastConnectAttemptTime > 0;
+        const timeSinceLastCommand = Date.now() - this.lastCommandTime;
+        const isIdle = timeSinceLastCommand >= IDLE_THRESHOLD;
+        let baseDelay;
+        if (this.isGracefulShutdown && this.reconnectAttempts < 3) {
+          baseDelay = 500 * Math.pow(2, this.reconnectAttempts);
+        } else if (wasRapidClose) {
+          baseDelay = Math.max(RAPID_CLOSE_BACKOFF, INITIAL_RECONNECT_DELAY * Math.pow(2, Math.min(this.reconnectAttempts, 6)));
+          console.log(`[EpisodaClient] Rapid close detected (${timeSinceConnect}ms), applying ${baseDelay / 1e3}s backoff`);
+        } else if (isIdle) {
+          baseDelay = IDLE_RECONNECT_DELAY;
+        } else {
+          const cappedAttempts = Math.min(this.reconnectAttempts, 6);
+          baseDelay = INITIAL_RECONNECT_DELAY * Math.pow(2, cappedAttempts);
+        }
+        const jitter = baseDelay * 0.25 * (Math.random() * 2 - 1);
+        const maxDelay = isIdle ? IDLE_RECONNECT_DELAY : MAX_RECONNECT_DELAY;
+        const delay = Math.min(baseDelay + jitter, maxDelay);
+        this.reconnectAttempts++;
+        const shutdownType = this.isGracefulShutdown ? "graceful" : "ungraceful";
+        const idleStatus = isIdle ? ", idle" : "";
+        const rapidStatus = wasRapidClose ? ", rapid-close" : "";
+        if (this.reconnectAttempts <= 5 || this.reconnectAttempts % 10 === 0) {
+          console.log(`[EpisodaClient] Reconnecting in ${Math.round(delay / 1e3)}s (attempt ${this.reconnectAttempts}, ${shutdownType}${idleStatus}${rapidStatus})`);
+        }
+        this.reconnectTimeout = setTimeout(() => {
+          console.log("[EpisodaClient] Attempting reconnection...");
+          this.connect(this.url, this.token, this.machineId, {
+            hostname: this.hostname,
+            osPlatform: this.osPlatform,
+            osArch: this.osArch,
+            daemonPid: this.daemonPid
+          }).then(() => {
+            console.log("[EpisodaClient] Reconnection successful, resetting retry counter");
+            this.reconnectAttempts = 0;
+            this.isGracefulShutdown = false;
+            this.firstDisconnectTime = void 0;
+            this.rateLimitBackoffUntil = void 0;
+          }).catch((error) => {
+            console.error("[EpisodaClient] Reconnection failed:", error);
+          });
+        }, delay);
+      }
+      /**
+       * EP605: Start client-side heartbeat to detect dead connections
+       *
+       * Sends ping every 45 seconds and expects pong within 15 seconds.
+       * If no pong received, terminates connection to trigger reconnection.
+       */
+      startHeartbeat() {
+        if (this.heartbeatTimer) {
+          clearInterval(this.heartbeatTimer);
+        }
+        this.heartbeatTimer = setInterval(() => {
+          if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
+            return;
+          }
+          try {
+            this.ws.ping();
+            if (this.heartbeatTimeoutTimer) {
+              clearTimeout(this.heartbeatTimeoutTimer);
+            }
+            this.heartbeatTimeoutTimer = setTimeout(() => {
+              console.log("[EpisodaClient] Heartbeat timeout - no pong received, terminating connection");
+              if (this.ws) {
+                this.ws.terminate();
+              }
+            }, CLIENT_HEARTBEAT_TIMEOUT);
+          } catch (error) {
+            console.error("[EpisodaClient] Error sending heartbeat ping:", error);
+          }
+        }, CLIENT_HEARTBEAT_INTERVAL);
+      }
+    };
+    exports2.EpisodaClient = EpisodaClient2;
+  }
+});
+
+// ../core/dist/auth.js
+var require_auth = __commonJS({
+  "../core/dist/auth.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getConfigDir = getConfigDir5;
+    exports2.getConfigPath = getConfigPath;
+    exports2.loadConfig = loadConfig2;
+    exports2.saveConfig = saveConfig2;
+    exports2.validateToken = validateToken;
+    var fs6 = __importStar(require("fs"));
+    var path7 = __importStar(require("path"));
+    var os4 = __importStar(require("os"));
+    var child_process_1 = require("child_process");
+    var DEFAULT_CONFIG_FILE = "config.json";
+    function getConfigDir5() {
+      return process.env.EPISODA_CONFIG_DIR || path7.join(os4.homedir(), ".episoda");
+    }
+    function getConfigPath(configPath) {
+      if (configPath) {
+        return configPath;
+      }
+      return path7.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
+    }
+    function ensureConfigDir(configPath) {
+      const dir = path7.dirname(configPath);
+      const isNew = !fs6.existsSync(dir);
+      if (isNew) {
+        fs6.mkdirSync(dir, { recursive: true, mode: 448 });
+      }
+      if (process.platform === "darwin") {
+        const nosyncPath = path7.join(dir, ".nosync");
+        if (isNew || !fs6.existsSync(nosyncPath)) {
+          try {
+            fs6.writeFileSync(nosyncPath, "", { mode: 384 });
+            (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
+              stdio: "ignore",
+              timeout: 5e3
+            });
+          } catch {
+          }
+        }
+      }
+    }
+    async function loadConfig2(configPath) {
+      const fullPath = getConfigPath(configPath);
+      if (!fs6.existsSync(fullPath)) {
+        return null;
+      }
+      try {
+        const content = fs6.readFileSync(fullPath, "utf8");
+        const config = JSON.parse(content);
+        return config;
+      } catch (error) {
+        console.error("Error loading config:", error);
+        return null;
+      }
+    }
+    async function saveConfig2(config, configPath) {
+      const fullPath = getConfigPath(configPath);
+      ensureConfigDir(fullPath);
+      try {
+        const content = JSON.stringify(config, null, 2);
+        fs6.writeFileSync(fullPath, content, { mode: 384 });
+      } catch (error) {
+        throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    async function validateToken(token) {
+      return Boolean(token && token.length > 0);
+    }
+  }
+});
+
+// ../core/dist/errors.js
+var require_errors = __commonJS({
+  "../core/dist/errors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.EpisodaError = void 0;
+    exports2.formatErrorMessage = formatErrorMessage;
+    var EpisodaError = class extends Error {
+      constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "EpisodaError";
+      }
+    };
+    exports2.EpisodaError = EpisodaError;
+    function formatErrorMessage(code, details) {
+      const messages = {
+        "GIT_NOT_INSTALLED": "Git is not installed or not in PATH",
+        "NOT_GIT_REPO": "Not a git repository",
+        "MERGE_CONFLICT": "Merge conflict detected",
+        "REBASE_CONFLICT": "Rebase conflict detected - resolve conflicts or abort rebase",
+        "UNCOMMITTED_CHANGES": "Uncommitted changes would be overwritten",
+        "NETWORK_ERROR": "Network error occurred",
+        "AUTH_FAILURE": "Authentication failed",
+        "BRANCH_NOT_FOUND": "Branch not found",
+        "BRANCH_ALREADY_EXISTS": "Branch already exists",
+        "PUSH_REJECTED": "Push rejected by remote",
+        "COMMAND_TIMEOUT": "Command timed out",
+        "UNKNOWN_ERROR": "Unknown error occurred"
+      };
+      let message = messages[code] || `Error: ${code}`;
+      if (details) {
+        if (details.uncommittedFiles && details.uncommittedFiles.length > 0) {
+          message += `
+Uncommitted files: ${details.uncommittedFiles.join(", ")}`;
+        }
+        if (details.conflictingFiles && details.conflictingFiles.length > 0) {
+          message += `
+Conflicting files: ${details.conflictingFiles.join(", ")}`;
+        }
+        if (details.branchName) {
+          message += `
+Branch: ${details.branchName}`;
+        }
+      }
+      return message;
+    }
+  }
+});
+
+// ../core/dist/index.js
+var require_dist = __commonJS({
+  "../core/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.VERSION = exports2.EpisodaClient = exports2.GitExecutor = void 0;
+    __exportStar(require_command_protocol(), exports2);
+    var git_executor_1 = require_git_executor();
+    Object.defineProperty(exports2, "GitExecutor", { enumerable: true, get: function() {
+      return git_executor_1.GitExecutor;
+    } });
+    var websocket_client_1 = require_websocket_client();
+    Object.defineProperty(exports2, "EpisodaClient", { enumerable: true, get: function() {
+      return websocket_client_1.EpisodaClient;
+    } });
+    __exportStar(require_auth(), exports2);
+    __exportStar(require_errors(), exports2);
+    __exportStar(require_git_validator(), exports2);
+    __exportStar(require_git_parser(), exports2);
+    var version_1 = require_version();
+    Object.defineProperty(exports2, "VERSION", { enumerable: true, get: function() {
+      return version_1.VERSION;
+    } });
+  }
+});
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "episoda",
+      version: "0.2.10",
+      description: "CLI tool for Episoda local development workflow orchestration",
+      main: "dist/index.js",
+      types: "dist/index.d.ts",
+      bin: {
+        episoda: "dist/index.js"
+      },
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch",
+        clean: "rm -rf dist",
+        typecheck: "tsc --noEmit"
+      },
+      keywords: [
+        "episoda",
+        "cli",
+        "git",
+        "workflow",
+        "development"
+      ],
+      author: "Episoda",
+      license: "MIT",
+      dependencies: {
+        chalk: "^4.1.2",
+        commander: "^11.1.0",
+        ora: "^5.4.1",
+        semver: "7.7.3",
+        ws: "^8.18.0",
+        zod: "^4.0.10"
+      },
+      devDependencies: {
+        "@episoda/core": "*",
+        "@types/node": "^20.11.24",
+        "@types/semver": "7.7.1",
+        "@types/ws": "^8.5.10",
+        tsup: "8.5.1",
+        typescript: "^5.3.3"
+      },
+      engines: {
+        node: ">=20.0.0"
+      },
+      files: [
+        "dist",
+        "README.md"
+      ],
+      repository: {
+        type: "git",
+        url: "https://github.com/v20x/episoda.git",
+        directory: "packages/episoda"
+      }
+    };
+  }
+});
+
+// src/daemon/machine-id.ts
+var os = __toESM(require("os"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var crypto = __toESM(require("crypto"));
+var import_child_process = require("child_process");
+var import_core = __toESM(require_dist());
+async function getMachineId() {
+  const machineIdPath = path.join((0, import_core.getConfigDir)(), "machine-id");
+  try {
+    if (fs.existsSync(machineIdPath)) {
+      const machineId2 = fs.readFileSync(machineIdPath, "utf-8").trim();
+      if (machineId2) {
+        return machineId2;
+      }
+    }
+  } catch (error) {
+  }
+  const machineId = generateMachineId();
+  try {
+    const dir = path.dirname(machineIdPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(machineIdPath, machineId, "utf-8");
+  } catch (error) {
+    console.error("Warning: Could not save machine ID to disk:", error);
+  }
+  return machineId;
+}
+function getHardwareUUID() {
+  try {
+    if (process.platform === "darwin") {
+      const output = (0, import_child_process.execSync)(
+        `ioreg -d2 -c IOPlatformExpertDevice | awk -F\\" '/IOPlatformUUID/{print $(NF-1)}'`,
+        { encoding: "utf-8", timeout: 5e3 }
+      ).trim();
+      if (output && output.length > 0) {
+        return output;
+      }
+    } else if (process.platform === "linux") {
+      if (fs.existsSync("/etc/machine-id")) {
+        const machineId = fs.readFileSync("/etc/machine-id", "utf-8").trim();
+        if (machineId && machineId.length > 0) {
+          return machineId;
+        }
+      }
+      if (fs.existsSync("/var/lib/dbus/machine-id")) {
+        const dbusId = fs.readFileSync("/var/lib/dbus/machine-id", "utf-8").trim();
+        if (dbusId && dbusId.length > 0) {
+          return dbusId;
+        }
+      }
+    } else if (process.platform === "win32") {
+      const output = (0, import_child_process.execSync)("wmic csproduct get uuid", {
+        encoding: "utf-8",
+        timeout: 5e3
+      });
+      const lines = output.trim().split("\n");
+      if (lines.length >= 2) {
+        const uuid = lines[1].trim();
+        if (uuid && uuid.length > 0 && uuid !== "UUID") {
+          return uuid;
+        }
+      }
+    }
+  } catch (error) {
+    console.warn("Could not get hardware UUID, using random fallback:", error);
+  }
+  return crypto.randomUUID();
+}
+function generateMachineId() {
+  const hostname4 = os.hostname();
+  const hwUUID = getHardwareUUID();
+  const shortId = hwUUID.replace(/-/g, "").slice(0, 8).toLowerCase();
+  return `${hostname4}-${shortId}`;
+}
+
+// src/daemon/project-tracker.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var import_core2 = __toESM(require_dist());
+function getProjectsFilePath() {
+  return path2.join((0, import_core2.getConfigDir)(), "projects.json");
+}
+function readProjects() {
+  const projectsPath = getProjectsFilePath();
+  try {
+    if (!fs2.existsSync(projectsPath)) {
+      return { projects: [] };
+    }
+    const content = fs2.readFileSync(projectsPath, "utf-8");
+    const data = JSON.parse(content);
+    if (!data.projects || !Array.isArray(data.projects)) {
+      console.warn("Invalid projects.json structure, resetting");
+      return { projects: [] };
+    }
+    return data;
+  } catch (error) {
+    console.error("Error reading projects.json:", error);
+    return { projects: [] };
+  }
+}
+function writeProjects(data) {
+  const projectsPath = getProjectsFilePath();
+  try {
+    const dir = path2.dirname(projectsPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.writeFileSync(projectsPath, JSON.stringify(data, null, 2), "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to write projects.json: ${error}`);
+  }
+}
+function addProject(projectId, projectPath) {
+  const data = readProjects();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existingByPath = data.projects.find((p) => p.path === projectPath);
+  if (existingByPath) {
+    existingByPath.id = projectId;
+    existingByPath.last_active = now;
+    writeProjects(data);
+    return existingByPath;
+  }
+  const existingByIdIndex = data.projects.findIndex((p) => p.id === projectId);
+  if (existingByIdIndex !== -1) {
+    const existingById = data.projects[existingByIdIndex];
+    console.log(`[ProjectTracker] Replacing project entry: ${existingById.path} -> ${projectPath}`);
+    data.projects.splice(existingByIdIndex, 1);
+  }
+  const projectName = path2.basename(projectPath);
+  const newProject = {
+    id: projectId,
+    path: projectPath,
+    name: projectName,
+    added_at: now,
+    last_active: now
+  };
+  data.projects.push(newProject);
+  writeProjects(data);
+  return newProject;
+}
+function removeProject(projectPath) {
+  const data = readProjects();
+  const initialLength = data.projects.length;
+  data.projects = data.projects.filter((p) => p.path !== projectPath);
+  if (data.projects.length < initialLength) {
+    writeProjects(data);
+    return true;
+  }
+  return false;
+}
+function getAllProjects() {
+  const data = readProjects();
+  return data.projects;
+}
+function touchProject(projectPath) {
+  const data = readProjects();
+  const project = data.projects.find((p) => p.path === projectPath);
+  if (project) {
+    project.last_active = (/* @__PURE__ */ new Date()).toISOString();
+    writeProjects(data);
+  }
+}
+
+// src/daemon/daemon-manager.ts
+var path3 = __toESM(require("path"));
+var import_core3 = __toESM(require_dist());
+function getPidFilePath() {
+  return path3.join((0, import_core3.getConfigDir)(), "daemon.pid");
+}
+
+// src/ipc/ipc-server.ts
+var net = __toESM(require("net"));
+var fs3 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var import_core4 = __toESM(require_dist());
+var getSocketPath = () => path4.join((0, import_core4.getConfigDir)(), "daemon.sock");
+var IPCServer = class {
+  constructor() {
+    this.server = null;
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a command handler
+   *
+   * @param command Command name
+   * @param handler Async function to handle command
+   */
+  on(command, handler) {
+    this.handlers.set(command, handler);
+  }
+  /**
+   * Start the IPC server
+   *
+   * Creates Unix socket and listens for connections.
+   */
+  async start() {
+    const socketPath = getSocketPath();
+    if (fs3.existsSync(socketPath)) {
+      fs3.unlinkSync(socketPath);
+    }
+    const dir = path4.dirname(socketPath);
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
+    }
+    this.server = net.createServer((socket) => {
+      this.handleConnection(socket);
+    });
+    return new Promise((resolve2, reject) => {
+      this.server.listen(socketPath, () => {
+        fs3.chmodSync(socketPath, 384);
+        resolve2();
+      });
+      this.server.on("error", reject);
+    });
+  }
+  /**
+   * Stop the IPC server
+   */
+  async stop() {
+    if (!this.server) return;
+    const socketPath = getSocketPath();
+    return new Promise((resolve2) => {
+      this.server.close(() => {
+        if (fs3.existsSync(socketPath)) {
+          fs3.unlinkSync(socketPath);
+        }
+        resolve2();
+      });
+    });
+  }
+  /**
+   * Handle incoming client connection
+   */
+  handleConnection(socket) {
+    let buffer = "";
+    socket.on("data", async (chunk) => {
+      buffer += chunk.toString();
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) return;
+      const message = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      try {
+        const request = JSON.parse(message);
+        const response = await this.handleRequest(request);
+        socket.write(JSON.stringify(response) + "\n");
+      } catch (error) {
+        const errorResponse = {
+          id: "unknown",
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+        socket.write(JSON.stringify(errorResponse) + "\n");
+      }
+    });
+    socket.on("error", (error) => {
+      console.error("[IPC Server] Socket error:", error);
+    });
+  }
+  /**
+   * Handle IPC request
+   */
+  async handleRequest(request) {
+    const handler = this.handlers.get(request.command);
+    if (!handler) {
+      return {
+        id: request.id,
+        success: false,
+        error: `Unknown command: ${request.command}`
+      };
+    }
+    try {
+      const data = await handler(request.params);
+      return {
+        id: request.id,
+        success: true,
+        data
+      };
+    } catch (error) {
+      return {
+        id: request.id,
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+
+// src/daemon/daemon-process.ts
+var import_core5 = __toESM(require_dist());
+
+// src/utils/update-checker.ts
+var import_child_process2 = require("child_process");
+var semver = __toESM(require("semver"));
+var PACKAGE_NAME = "episoda";
+var NPM_REGISTRY = "https://registry.npmjs.org";
+async function checkForUpdates(currentVersion) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(`${NPM_REGISTRY}/${PACKAGE_NAME}/latest`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return { currentVersion, latestVersion: currentVersion, updateAvailable: false };
+    }
+    const data = await response.json();
+    const latestVersion = data.version;
+    return {
+      currentVersion,
+      latestVersion,
+      updateAvailable: semver.gt(latestVersion, currentVersion)
+    };
+  } catch (error) {
+    return { currentVersion, latestVersion: currentVersion, updateAvailable: false };
+  }
+}
+function performBackgroundUpdate() {
+  try {
+    const child = (0, import_child_process2.spawn)("npm", ["update", "-g", PACKAGE_NAME], {
+      detached: true,
+      stdio: "ignore",
+      // Use shell on Windows for proper npm execution
+      shell: process.platform === "win32"
+    });
+    child.unref();
+  } catch (error) {
+  }
+}
+
+// src/daemon/identity-server.ts
+var http = __toESM(require("http"));
+var os2 = __toESM(require("os"));
+var IDENTITY_SERVER_PORT = 3002;
+var IdentityServer = class {
+  constructor(machineId) {
+    this.server = null;
+    this.isConnected = false;
+    this.machineId = machineId;
+  }
+  /**
+   * Update connection status
+   * Called when WebSocket connection state changes
+   */
+  setConnected(connected) {
+    this.isConnected = connected;
+  }
+  /**
+   * Start the identity server on localhost:3002
+   */
+  async start() {
+    return new Promise((resolve2, reject) => {
+      this.server = http.createServer((req, res) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        res.setHeader("Access-Control-Allow-Private-Network", "true");
+        if (req.method === "OPTIONS") {
+          res.writeHead(204);
+          res.end();
+          return;
+        }
+        if (req.method !== "GET") {
+          res.writeHead(405, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Method not allowed" }));
+          return;
+        }
+        const url = new URL(req.url || "/", `http://${req.headers.host}`);
+        if (url.pathname === "/identity") {
+          const response = {
+            machineId: this.machineId,
+            hostname: os2.hostname(),
+            platform: os2.platform(),
+            arch: os2.arch(),
+            connected: this.isConnected
+          };
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(response));
+          return;
+        }
+        if (url.pathname === "/health") {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ status: "ok", machineId: this.machineId }));
+          return;
+        }
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
+      });
+      this.server.listen(IDENTITY_SERVER_PORT, "127.0.0.1", () => {
+        console.log(`[IdentityServer] Started on http://127.0.0.1:${IDENTITY_SERVER_PORT}`);
+        resolve2();
+      });
+      this.server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          console.warn(`[IdentityServer] Port ${IDENTITY_SERVER_PORT} already in use, skipping`);
+          resolve2();
+        } else {
+          console.error("[IdentityServer] Failed to start:", err.message);
+          reject(err);
+        }
+      });
+    });
+  }
+  /**
+   * Stop the identity server
+   */
+  async stop() {
+    return new Promise((resolve2) => {
+      if (this.server) {
+        this.server.close(() => {
+          console.log("[IdentityServer] Stopped");
+          this.server = null;
+          resolve2();
+        });
+      } else {
+        resolve2();
+      }
+    });
+  }
+};
+
+// src/daemon/handlers/file-handlers.ts
+var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var readline = __toESM(require("readline"));
+var DEFAULT_MAX_FILE_SIZE = 20 * 1024 * 1024;
+function validatePath(filePath, projectPath) {
+  const normalizedProjectPath = path5.resolve(projectPath);
+  const absolutePath = path5.isAbsolute(filePath) ? path5.resolve(filePath) : path5.resolve(projectPath, filePath);
+  const normalizedPath = path5.normalize(absolutePath);
+  if (!normalizedPath.startsWith(normalizedProjectPath + path5.sep) && normalizedPath !== normalizedProjectPath) {
+    return null;
+  }
+  return normalizedPath;
+}
+async function handleFileRead(command, projectPath) {
+  const { path: filePath, encoding = "base64", maxSize = DEFAULT_MAX_FILE_SIZE } = command;
+  const validPath = validatePath(filePath, projectPath);
+  if (!validPath) {
+    return {
+      success: false,
+      error: "Invalid path: directory traversal not allowed"
+    };
+  }
+  try {
+    if (!fs4.existsSync(validPath)) {
+      return {
+        success: false,
+        error: "File not found"
+      };
+    }
+    const stats = fs4.statSync(validPath);
+    if (stats.isDirectory()) {
+      return {
+        success: false,
+        error: "Path is a directory, not a file"
+      };
+    }
+    if (stats.size > maxSize) {
+      return {
+        success: false,
+        error: `File too large: ${stats.size} bytes exceeds limit of ${maxSize} bytes`
+      };
+    }
+    const buffer = fs4.readFileSync(validPath);
+    let content;
+    if (encoding === "base64") {
+      content = buffer.toString("base64");
+    } else {
+      content = buffer.toString("utf8");
+    }
+    return {
+      success: true,
+      content,
+      encoding,
+      size: stats.size
+    };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    const isPermissionError = errMsg.includes("EACCES") || errMsg.includes("permission");
+    return {
+      success: false,
+      error: isPermissionError ? "Permission denied" : "Failed to read file"
+    };
+  }
+}
+async function handleFileWrite(command, projectPath) {
+  const { path: filePath, content, encoding = "utf8", createDirs = true } = command;
+  const validPath = validatePath(filePath, projectPath);
+  if (!validPath) {
+    return {
+      success: false,
+      error: "Invalid path: directory traversal not allowed"
+    };
+  }
+  try {
+    if (createDirs) {
+      const dirPath = path5.dirname(validPath);
+      if (!fs4.existsSync(dirPath)) {
+        fs4.mkdirSync(dirPath, { recursive: true });
+      }
+    }
+    let buffer;
+    if (encoding === "base64") {
+      buffer = Buffer.from(content, "base64");
+    } else {
+      buffer = Buffer.from(content, "utf8");
+    }
+    const tempPath = `${validPath}.tmp.${Date.now()}`;
+    fs4.writeFileSync(tempPath, buffer);
+    fs4.renameSync(tempPath, validPath);
+    return {
+      success: true,
+      bytesWritten: buffer.length
+    };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    const isPermissionError = errMsg.includes("EACCES") || errMsg.includes("permission");
+    const isDiskError = errMsg.includes("ENOSPC") || errMsg.includes("no space");
+    return {
+      success: false,
+      error: isPermissionError ? "Permission denied" : isDiskError ? "Disk full" : "Failed to write file"
+    };
+  }
+}
+async function handleFileList(command, projectPath) {
+  const { path: dirPath, recursive = false, includeHidden = false } = command;
+  const validPath = validatePath(dirPath, projectPath);
+  if (!validPath) {
+    return {
+      success: false,
+      error: "Invalid path: directory traversal not allowed"
+    };
+  }
+  try {
+    if (!fs4.existsSync(validPath)) {
+      return {
+        success: false,
+        error: "Directory not found"
+      };
+    }
+    const stats = fs4.statSync(validPath);
+    if (!stats.isDirectory()) {
+      return {
+        success: false,
+        error: "Path is not a directory"
+      };
+    }
+    const entries = [];
+    if (recursive) {
+      await listDirectoryRecursive(validPath, validPath, entries, includeHidden);
+    } else {
+      const dirEntries = await fs4.promises.readdir(validPath, { withFileTypes: true });
+      for (const entry of dirEntries) {
+        if (!includeHidden && entry.name.startsWith(".")) continue;
+        const entryPath = path5.join(validPath, entry.name);
+        const entryStats = await fs4.promises.stat(entryPath);
+        entries.push({
+          name: entry.name,
+          type: entry.isDirectory() ? "directory" : "file",
+          size: entryStats.size
+        });
+      }
+    }
+    return {
+      success: true,
+      entries
+    };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    const isPermissionError = errMsg.includes("EACCES") || errMsg.includes("permission");
+    return {
+      success: false,
+      error: isPermissionError ? "Permission denied" : "Failed to list directory"
+    };
+  }
+}
+async function listDirectoryRecursive(basePath, currentPath, entries, includeHidden) {
+  const dirEntries = await fs4.promises.readdir(currentPath, { withFileTypes: true });
+  for (const entry of dirEntries) {
+    if (!includeHidden && entry.name.startsWith(".")) continue;
+    const entryPath = path5.join(currentPath, entry.name);
+    const relativePath = path5.relative(basePath, entryPath);
+    try {
+      const entryStats = await fs4.promises.stat(entryPath);
+      entries.push({
+        name: relativePath,
+        type: entry.isDirectory() ? "directory" : "file",
+        size: entryStats.size
+      });
+      if (entry.isDirectory()) {
+        await listDirectoryRecursive(basePath, entryPath, entries, includeHidden);
+      }
+    } catch {
+    }
+  }
+}
+async function handleFileSearch(command, projectPath) {
+  const { pattern, basePath, maxResults = 100 } = command;
+  const effectiveMaxResults = Math.min(Math.max(1, maxResults), 1e3);
+  const validPath = validatePath(basePath, projectPath);
+  if (!validPath) {
+    return {
+      success: false,
+      error: "Invalid path: directory traversal not allowed"
+    };
+  }
+  try {
+    if (!fs4.existsSync(validPath)) {
+      return {
+        success: false,
+        error: "Directory not found"
+      };
+    }
+    const files = [];
+    const globRegex = globToRegex(pattern);
+    await searchFilesRecursive(validPath, validPath, globRegex, files, effectiveMaxResults);
+    return {
+      success: true,
+      files
+    };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    const isPermissionError = errMsg.includes("EACCES") || errMsg.includes("permission");
+    return {
+      success: false,
+      error: isPermissionError ? "Permission denied" : "Failed to search files"
+    };
+  }
+}
+function globToRegex(pattern) {
+  let i = 0;
+  let regexStr = "";
+  while (i < pattern.length) {
+    const char = pattern[i];
+    if (char === "*" && pattern[i + 1] === "*") {
+      regexStr += ".*";
+      i += 2;
+      if (pattern[i] === "/") i++;
+      continue;
+    }
+    if (char === "*") {
+      regexStr += "[^/]*";
+      i++;
+      continue;
+    }
+    if (char === "?") {
+      regexStr += "[^/]";
+      i++;
+      continue;
+    }
+    if (char === "{") {
+      const closeIdx = pattern.indexOf("}", i);
+      if (closeIdx !== -1) {
+        const options = pattern.slice(i + 1, closeIdx).split(",");
+        const escaped = options.map((opt) => escapeRegexChars(opt));
+        regexStr += `(?:${escaped.join("|")})`;
+        i = closeIdx + 1;
+        continue;
+      }
+    }
+    if (char === "[") {
+      const closeIdx = findClosingBracket(pattern, i);
+      if (closeIdx !== -1) {
+        let classContent = pattern.slice(i + 1, closeIdx);
+        if (classContent.startsWith("!")) {
+          classContent = "^" + classContent.slice(1);
+        }
+        regexStr += `[${classContent}]`;
+        i = closeIdx + 1;
+        continue;
+      }
+    }
+    if (".+^${}()|[]\\".includes(char)) {
+      regexStr += "\\" + char;
+    } else {
+      regexStr += char;
+    }
+    i++;
+  }
+  return new RegExp(`^${regexStr}$`);
+}
+function escapeRegexChars(str) {
+  return str.replace(/[.+^${}()|[\]\\*?]/g, "\\$&");
+}
+function findClosingBracket(pattern, start) {
+  let i = start + 1;
+  if (pattern[i] === "!" || pattern[i] === "^") i++;
+  if (pattern[i] === "]") i++;
+  while (i < pattern.length) {
+    if (pattern[i] === "]") return i;
+    if (pattern[i] === "\\" && i + 1 < pattern.length) i++;
+    i++;
+  }
+  return -1;
+}
+async function searchFilesRecursive(basePath, currentPath, pattern, files, maxResults) {
+  if (files.length >= maxResults) return;
+  const entries = await fs4.promises.readdir(currentPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (files.length >= maxResults) return;
+    if (entry.name.startsWith(".")) continue;
+    const entryPath = path5.join(currentPath, entry.name);
+    const relativePath = path5.relative(basePath, entryPath);
+    try {
+      if (entry.isDirectory()) {
+        await searchFilesRecursive(basePath, entryPath, pattern, files, maxResults);
+      } else if (pattern.test(relativePath) || pattern.test(entry.name)) {
+        files.push(relativePath);
+      }
+    } catch {
+    }
+  }
+}
+async function handleFileGrep(command, projectPath) {
+  const {
+    pattern,
+    path: searchPath,
+    filePattern = "*",
+    caseSensitive = true,
+    maxResults = 100
+  } = command;
+  const effectiveMaxResults = Math.min(Math.max(1, maxResults), 1e3);
+  const validPath = validatePath(searchPath, projectPath);
+  if (!validPath) {
+    return {
+      success: false,
+      error: "Invalid path: directory traversal not allowed"
+    };
+  }
+  try {
+    if (!fs4.existsSync(validPath)) {
+      return {
+        success: false,
+        error: "Path not found"
+      };
+    }
+    const matches = [];
+    const searchRegex = new RegExp(pattern, caseSensitive ? "" : "i");
+    const fileGlobRegex = globToRegex(filePattern);
+    const stats = fs4.statSync(validPath);
+    if (stats.isFile()) {
+      await grepFile(validPath, validPath, searchRegex, matches, effectiveMaxResults);
+    } else {
+      await grepDirectoryRecursive(validPath, validPath, searchRegex, fileGlobRegex, matches, effectiveMaxResults);
+    }
+    return {
+      success: true,
+      matches
+    };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    const isPermissionError = errMsg.includes("EACCES") || errMsg.includes("permission");
+    return {
+      success: false,
+      error: isPermissionError ? "Permission denied" : "Failed to search content"
+    };
+  }
+}
+async function grepFile(basePath, filePath, pattern, matches, maxResults) {
+  if (matches.length >= maxResults) return;
+  const relativePath = path5.relative(basePath, filePath);
+  const fileStream = fs4.createReadStream(filePath, { encoding: "utf8" });
+  const rl = readline.createInterface({
+    input: fileStream,
+    crlfDelay: Infinity
+  });
+  let lineNumber = 0;
+  for await (const line of rl) {
+    lineNumber++;
+    if (matches.length >= maxResults) {
+      rl.close();
+      break;
+    }
+    if (pattern.test(line)) {
+      matches.push({
+        file: relativePath || path5.basename(filePath),
+        line: lineNumber,
+        content: line.slice(0, 500)
+        // Truncate long lines
+      });
+    }
+  }
+}
+async function grepDirectoryRecursive(basePath, currentPath, searchPattern, filePattern, matches, maxResults) {
+  if (matches.length >= maxResults) return;
+  const entries = await fs4.promises.readdir(currentPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (matches.length >= maxResults) return;
+    if (entry.name.startsWith(".")) continue;
+    const entryPath = path5.join(currentPath, entry.name);
+    try {
+      if (entry.isDirectory()) {
+        await grepDirectoryRecursive(basePath, entryPath, searchPattern, filePattern, matches, maxResults);
+      } else if (filePattern.test(entry.name)) {
+        await grepFile(basePath, entryPath, searchPattern, matches, maxResults);
+      }
+    } catch {
+    }
+  }
+}
+
+// src/daemon/handlers/exec-handler.ts
+var import_child_process3 = require("child_process");
+var DEFAULT_TIMEOUT = 3e4;
+var MAX_TIMEOUT = 3e5;
+async function handleExec(command, projectPath) {
+  const {
+    command: cmd,
+    cwd = projectPath,
+    timeout = DEFAULT_TIMEOUT,
+    env = {}
+  } = command;
+  const effectiveTimeout = Math.min(Math.max(timeout, 1e3), MAX_TIMEOUT);
+  return new Promise((resolve2) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let resolved = false;
+    const done = (result) => {
+      if (resolved) return;
+      resolved = true;
+      resolve2(result);
+    };
+    try {
+      const proc = (0, import_child_process3.spawn)(cmd, {
+        shell: true,
+        cwd,
+        env: { ...process.env, ...env },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const timeoutId = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+        setTimeout(() => {
+          if (!resolved) {
+            proc.kill("SIGKILL");
+          }
+        }, 5e3);
+      }, effectiveTimeout);
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+        if (stdout.length > 10 * 1024 * 1024) {
+          stdout = stdout.slice(-10 * 1024 * 1024);
+        }
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+        if (stderr.length > 10 * 1024 * 1024) {
+          stderr = stderr.slice(-10 * 1024 * 1024);
+        }
+      });
+      proc.on("close", (code, signal) => {
+        clearTimeout(timeoutId);
+        done({
+          success: code === 0 && !timedOut,
+          stdout,
+          stderr,
+          exitCode: code ?? -1,
+          timedOut,
+          error: timedOut ? `Command timed out after ${effectiveTimeout}ms` : code !== 0 ? `Command exited with code ${code}` : void 0
+        });
+      });
+      proc.on("error", (error) => {
+        clearTimeout(timeoutId);
+        done({
+          success: false,
+          stdout,
+          stderr,
+          exitCode: -1,
+          error: `Failed to execute command: ${error.message}`
+        });
+      });
+    } catch (error) {
+      done({
+        success: false,
+        stdout: "",
+        stderr: "",
+        exitCode: -1,
+        error: `Failed to spawn process: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  });
+}
+
+// src/daemon/daemon-process.ts
+var fs5 = __toESM(require("fs"));
+var os3 = __toESM(require("os"));
+var path6 = __toESM(require("path"));
+var packageJson = require_package();
+var Daemon = class {
+  constructor() {
+    this.machineId = "";
+    this.deviceId = null;
+    // EP726: Cached device UUID from server
+    this.deviceName = null;
+    // EP661: Cached device name from server
+    this.flyMachineId = null;
+    this.identityServer = null;
+    // EP803: Local identity server for browser detection
+    this.connections = /* @__PURE__ */ new Map();
+    // projectPath -> connection
+    // EP701: Track which connections are currently live (WebSocket open)
+    // Updated by 'auth_success' (add) and 'disconnected' (remove) events
+    this.liveConnections = /* @__PURE__ */ new Set();
+    // projectPath
+    this.shuttingDown = false;
+    this.ipcServer = new IPCServer();
+  }
+  /**
+   * Start the daemon
+   */
+  async start() {
+    console.log("[Daemon] Starting Episoda daemon...");
+    this.machineId = await getMachineId();
+    console.log(`[Daemon] Machine ID: ${this.machineId}`);
+    const config = await (0, import_core5.loadConfig)();
+    if (config?.device_id) {
+      this.deviceId = config.device_id;
+      console.log(`[Daemon] Loaded cached Device ID (UUID): ${this.deviceId}`);
+    }
+    await this.ipcServer.start();
+    console.log("[Daemon] IPC server started");
+    this.identityServer = new IdentityServer(this.machineId);
+    await this.identityServer.start();
+    this.registerIPCHandlers();
+    await this.restoreConnections();
+    this.setupShutdownHandlers();
+    console.log("[Daemon] Daemon started successfully");
+    this.checkAndNotifyUpdates();
+  }
+  /**
+   * EP783: Check for CLI updates and auto-update in background
+   * Non-blocking - runs after daemon starts, fails silently on errors
+   */
+  async checkAndNotifyUpdates() {
+    try {
+      const result = await checkForUpdates(packageJson.version);
+      if (result.updateAvailable) {
+        console.log(`
+\u2B06\uFE0F  Update available: ${result.currentVersion} \u2192 ${result.latestVersion}`);
+        console.log("   Updating in background...\n");
+        performBackgroundUpdate();
+      }
+    } catch (error) {
+    }
+  }
+  // EP738: Removed startHttpServer - device info now flows through WebSocket broadcast + database
+  /**
+   * Register IPC command handlers
+   */
+  registerIPCHandlers() {
+    this.ipcServer.on("ping", async () => {
+      return { status: "ok" };
+    });
+    this.ipcServer.on("status", async () => {
+      const projects = getAllProjects().map((p) => ({
+        id: p.id,
+        path: p.path,
+        name: p.name,
+        connected: this.liveConnections.has(p.path)
+      }));
+      return {
+        running: true,
+        machineId: this.machineId,
+        deviceId: this.deviceId,
+        // EP726: UUID for unified device identification
+        hostname: os3.hostname(),
+        platform: os3.platform(),
+        arch: os3.arch(),
+        projects
+      };
+    });
+    this.ipcServer.on("add-project", async (params) => {
+      const { projectId, projectPath } = params;
+      addProject(projectId, projectPath);
+      try {
+        await this.connectProject(projectId, projectPath);
+        const isHealthy = this.isConnectionHealthy(projectPath);
+        if (!isHealthy) {
+          console.warn(`[Daemon] Connection completed but not healthy for ${projectPath}`);
+          return { success: false, connected: false, error: "Connection established but not healthy" };
+        }
+        return { success: true, connected: true };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, connected: false, error: errorMessage };
+      }
+    });
+    this.ipcServer.on("remove-project", async (params) => {
+      const { projectPath } = params;
+      await this.disconnectProject(projectPath);
+      removeProject(projectPath);
+      return { success: true };
+    });
+    this.ipcServer.on("connect-project", async (params) => {
+      const { projectPath } = params;
+      const project = getAllProjects().find((p) => p.path === projectPath);
+      if (!project) {
+        throw new Error("Project not tracked");
+      }
+      await this.connectProject(project.id, projectPath);
+      return { success: true };
+    });
+    this.ipcServer.on("disconnect-project", async (params) => {
+      const { projectPath } = params;
+      await this.disconnectProject(projectPath);
+      return { success: true };
+    });
+    this.ipcServer.on("shutdown", async () => {
+      console.log("[Daemon] Shutdown requested via IPC");
+      await this.shutdown();
+      return { success: true };
+    });
+    this.ipcServer.on("verify-health", async () => {
+      const projects = getAllProjects().map((p) => ({
+        id: p.id,
+        path: p.path,
+        name: p.name,
+        inConnectionsMap: this.connections.has(p.path),
+        inLiveConnections: this.liveConnections.has(p.path),
+        isHealthy: this.isConnectionHealthy(p.path)
+      }));
+      const healthyCount = projects.filter((p) => p.isHealthy).length;
+      const staleCount = projects.filter((p) => p.inConnectionsMap && !p.inLiveConnections).length;
+      return {
+        totalProjects: projects.length,
+        healthyConnections: healthyCount,
+        staleConnections: staleCount,
+        projects
+      };
+    });
+  }
+  /**
+   * Restore WebSocket connections for tracked projects
+   */
+  async restoreConnections() {
+    const projects = getAllProjects();
+    for (const project of projects) {
+      try {
+        await this.connectProject(project.id, project.path);
+      } catch (error) {
+        console.error(`[Daemon] Failed to restore connection for ${project.name}:`, error);
+      }
+    }
+  }
+  /**
+   * EP805: Check if a connection is healthy (exists AND is live)
+   * A connection can exist in the Map but be dead if WebSocket disconnected
+   */
+  isConnectionHealthy(projectPath) {
+    return this.connections.has(projectPath) && this.liveConnections.has(projectPath);
+  }
+  /**
+   * Connect to a project's WebSocket
+   */
+  async connectProject(projectId, projectPath) {
+    if (this.connections.has(projectPath)) {
+      if (this.liveConnections.has(projectPath)) {
+        console.log(`[Daemon] Already connected to ${projectPath}`);
+        return;
+      }
+      console.warn(`[Daemon] Stale connection detected for ${projectPath}, forcing reconnection`);
+      await this.disconnectProject(projectPath);
+    }
+    const config = await (0, import_core5.loadConfig)();
+    if (!config || !config.access_token) {
+      throw new Error("No access token found. Please run: episoda auth");
+    }
+    let serverUrl = config.api_url || process.env.EPISODA_API_URL || "https://episoda.dev";
+    if (config.project_settings?.local_server_url) {
+      serverUrl = config.project_settings.local_server_url;
+      console.log(`[Daemon] Using cached server URL: ${serverUrl}`);
+    }
+    const serverUrlObj = new URL(serverUrl);
+    const wsProtocol = serverUrlObj.protocol === "https:" ? "wss:" : "ws:";
+    const wsPort = process.env.EPISODA_WS_PORT || "3001";
+    const wsUrl = `${wsProtocol}//${serverUrlObj.hostname}:${wsPort}`;
+    console.log(`[Daemon] Connecting to ${wsUrl} for project ${projectId}...`);
+    const client = new import_core5.EpisodaClient();
+    const gitExecutor = new import_core5.GitExecutor();
+    const connection = {
+      projectId,
+      projectPath,
+      client,
+      gitExecutor
+    };
+    this.connections.set(projectPath, connection);
+    client.on("command", async (message) => {
+      if (message.type === "command" && message.command) {
+        console.log(`[Daemon] Received command for ${projectId}:`, message.command);
+        client.updateActivity();
+        try {
+          const result = await gitExecutor.execute(message.command, {
+            cwd: projectPath
+          });
+          await client.send({
+            type: "result",
+            commandId: message.id,
+            result
+          });
+          console.log(`[Daemon] Command completed for ${projectId}:`, result.success ? "success" : "failed");
+        } catch (error) {
+          await client.send({
+            type: "result",
+            commandId: message.id,
+            result: {
+              success: false,
+              error: "UNKNOWN_ERROR",
+              output: error instanceof Error ? error.message : String(error)
+            }
+          });
+          console.error(`[Daemon] Command execution error for ${projectId}:`, error);
+        }
+      }
+    });
+    client.on("remote_command", async (message) => {
+      if (message.type === "remote_command" && message.command) {
+        const cmd = message.command;
+        console.log(`[Daemon] Received remote command for ${projectId}:`, cmd.action);
+        client.updateActivity();
+        try {
+          let result;
+          switch (cmd.action) {
+            case "file:read":
+              result = await handleFileRead(cmd, projectPath);
+              break;
+            case "file:write":
+              result = await handleFileWrite(cmd, projectPath);
+              break;
+            case "file:list":
+              result = await handleFileList(cmd, projectPath);
+              break;
+            case "file:search":
+              result = await handleFileSearch(cmd, projectPath);
+              break;
+            case "file:grep":
+              result = await handleFileGrep(cmd, projectPath);
+              break;
+            case "exec":
+              result = await handleExec(cmd, projectPath);
+              break;
+            default:
+              result = {
+                success: false,
+                error: `Unknown remote command action: ${cmd.action}`
+              };
+          }
+          await client.send({
+            type: "remote_result",
+            commandId: message.id,
+            result
+          });
+          console.log(`[Daemon] Remote command ${cmd.action} completed for ${projectId}:`, result.success ? "success" : "failed");
+        } catch (error) {
+          await client.send({
+            type: "remote_result",
+            commandId: message.id,
+            result: {
+              success: false,
+              error: error instanceof Error ? error.message : String(error)
+            }
+          });
+          console.error(`[Daemon] Remote command execution error for ${projectId}:`, error);
+        }
+      }
+    });
+    client.on("shutdown", async (message) => {
+      const shutdownMessage = message;
+      const reason = shutdownMessage.reason || "unknown";
+      console.log(`[Daemon] Received shutdown request from server for ${projectId}`);
+      console.log(`[Daemon] Reason: ${reason} - ${shutdownMessage.message || "No message"}`);
+      if (reason === "user_requested") {
+        console.log(`[Daemon] User requested disconnect, shutting down...`);
+        await this.cleanupAndExit();
+      } else {
+        console.log(`[Daemon] Server shutdown (${reason}), will reconnect automatically...`);
+      }
+    });
+    client.on("auth_success", async (message) => {
+      console.log(`[Daemon] Authenticated for project ${projectId}`);
+      touchProject(projectPath);
+      this.liveConnections.add(projectPath);
+      if (this.identityServer) {
+        this.identityServer.setConnected(true);
+      }
+      const authMessage = message;
+      if (authMessage.userId && authMessage.workspaceId) {
+        await this.configureGitUser(projectPath, authMessage.userId, authMessage.workspaceId, this.machineId, projectId, authMessage.deviceId);
+        await this.installGitHooks(projectPath);
+      }
+      if (authMessage.deviceName) {
+        this.deviceName = authMessage.deviceName;
+        console.log(`[Daemon] Device name: ${this.deviceName}`);
+      }
+      if (authMessage.deviceId) {
+        this.deviceId = authMessage.deviceId;
+        console.log(`[Daemon] Device ID (UUID): ${this.deviceId}`);
+        await this.cacheDeviceId(authMessage.deviceId);
+      }
+      if (authMessage.flyMachineId) {
+        this.flyMachineId = authMessage.flyMachineId;
+        console.log(`[Daemon] Fly Machine ID: ${this.flyMachineId}`);
+      }
+    });
+    client.on("error", (message) => {
+      console.error(`[Daemon] Server error for ${projectId}:`, message);
+    });
+    client.on("disconnected", (event) => {
+      const disconnectEvent = event;
+      console.log(`[Daemon] Connection closed for ${projectId}: code=${disconnectEvent.code}, willReconnect=${disconnectEvent.willReconnect}`);
+      this.liveConnections.delete(projectPath);
+      if (this.identityServer && this.liveConnections.size === 0) {
+        this.identityServer.setConnected(false);
+      }
+      if (!disconnectEvent.willReconnect) {
+        this.connections.delete(projectPath);
+        console.log(`[Daemon] Removed connection for ${projectPath} from map`);
+      }
+    });
+    try {
+      let daemonPid;
+      try {
+        const pidPath = getPidFilePath();
+        if (fs5.existsSync(pidPath)) {
+          const pidStr = fs5.readFileSync(pidPath, "utf-8").trim();
+          daemonPid = parseInt(pidStr, 10);
+        }
+      } catch (pidError) {
+        console.warn(`[Daemon] Could not read daemon PID:`, pidError instanceof Error ? pidError.message : pidError);
+      }
+      await client.connect(wsUrl, config.access_token, this.machineId, {
+        hostname: os3.hostname(),
+        osPlatform: os3.platform(),
+        osArch: os3.arch(),
+        daemonPid
+      });
+      console.log(`[Daemon] Successfully connected to project ${projectId}`);
+    } catch (error) {
+      console.error(`[Daemon] Failed to connect to ${projectId}:`, error);
+      this.connections.delete(projectPath);
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from a project's WebSocket
+   */
+  async disconnectProject(projectPath) {
+    const connection = this.connections.get(projectPath);
+    if (!connection) {
+      return;
+    }
+    if (connection.reconnectTimer) {
+      clearTimeout(connection.reconnectTimer);
+    }
+    await connection.client.disconnect();
+    this.connections.delete(projectPath);
+    this.liveConnections.delete(projectPath);
+    console.log(`[Daemon] Disconnected from ${projectPath}`);
+  }
+  /**
+   * Setup graceful shutdown handlers
+   * EP613: Now uses cleanupAndExit to ensure PID file is removed
+   */
+  setupShutdownHandlers() {
+    const shutdownHandler = async (signal) => {
+      console.log(`[Daemon] Received ${signal}, shutting down...`);
+      await this.cleanupAndExit();
+    };
+    process.on("SIGTERM", () => shutdownHandler("SIGTERM"));
+    process.on("SIGINT", () => shutdownHandler("SIGINT"));
+  }
+  /**
+   * EP595: Configure git with user and workspace ID for post-checkout hook
+   * EP655: Added machineId for device isolation in multi-device environments
+   * EP725: Added projectId for main branch badge tracking
+   * EP726: Added deviceId (UUID) for unified device identification
+   *
+   * This stores the IDs in .git/config so the post-checkout hook can
+   * update module.checkout_* fields when git operations happen from terminal.
+   */
+  async configureGitUser(projectPath, userId, workspaceId, machineId, projectId, deviceId) {
+    try {
+      const { execSync: execSync2 } = await import("child_process");
+      execSync2(`git config episoda.userId ${userId}`, {
+        cwd: projectPath,
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      execSync2(`git config episoda.workspaceId ${workspaceId}`, {
+        cwd: projectPath,
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      execSync2(`git config episoda.machineId ${machineId}`, {
+        cwd: projectPath,
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      execSync2(`git config episoda.projectId ${projectId}`, {
+        cwd: projectPath,
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      if (deviceId) {
+        execSync2(`git config episoda.deviceId ${deviceId}`, {
+          cwd: projectPath,
+          encoding: "utf8",
+          stdio: "pipe"
+        });
+      }
+      console.log(`[Daemon] Configured git for project: episoda.userId=${userId}, machineId=${machineId}, projectId=${projectId}${deviceId ? `, deviceId=${deviceId}` : ""}`);
+    } catch (error) {
+      console.warn(`[Daemon] Failed to configure git user for ${projectPath}:`, error instanceof Error ? error.message : error);
+    }
+  }
+  /**
+   * EP610: Install git hooks from bundled files
+   *
+   * Installs post-checkout and pre-commit hooks to enable:
+   * - Branch tracking (post-checkout updates module.checkout_* fields)
+   * - Main branch protection (pre-commit blocks direct commits to main)
+   */
+  async installGitHooks(projectPath) {
+    const hooks = ["post-checkout", "pre-commit"];
+    const hooksDir = path6.join(projectPath, ".git", "hooks");
+    if (!fs5.existsSync(hooksDir)) {
+      console.warn(`[Daemon] Hooks directory not found: ${hooksDir}`);
+      return;
+    }
+    for (const hookName of hooks) {
+      try {
+        const hookPath = path6.join(hooksDir, hookName);
+        const bundledHookPath = path6.join(__dirname, "..", "hooks", hookName);
+        if (!fs5.existsSync(bundledHookPath)) {
+          console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
+          continue;
+        }
+        const hookContent = fs5.readFileSync(bundledHookPath, "utf-8");
+        if (fs5.existsSync(hookPath)) {
+          const existingContent = fs5.readFileSync(hookPath, "utf-8");
+          if (existingContent === hookContent) {
+            continue;
+          }
+        }
+        fs5.writeFileSync(hookPath, hookContent, { mode: 493 });
+        console.log(`[Daemon] Installed git hook: ${hookName}`);
+      } catch (error) {
+        console.warn(`[Daemon] Failed to install ${hookName} hook:`, error instanceof Error ? error.message : error);
+      }
+    }
+  }
+  /**
+   * EP726: Cache device UUID to config file
+   *
+   * Persists the device_id (UUID) received from the server so it's available
+   * on daemon restart without needing to re-register the device.
+   */
+  async cacheDeviceId(deviceId) {
+    try {
+      const config = await (0, import_core5.loadConfig)();
+      if (!config) {
+        console.warn("[Daemon] Cannot cache device ID - no config found");
+        return;
+      }
+      if (config.device_id === deviceId) {
+        return;
+      }
+      const updatedConfig = {
+        ...config,
+        device_id: deviceId,
+        machine_id: this.machineId
+      };
+      await (0, import_core5.saveConfig)(updatedConfig);
+      console.log(`[Daemon] Cached device ID to config: ${deviceId}`);
+    } catch (error) {
+      console.warn("[Daemon] Failed to cache device ID:", error instanceof Error ? error.message : error);
+    }
+  }
+  /**
+   * Gracefully shutdown daemon
+   */
+  async shutdown() {
+    if (this.shuttingDown) return;
+    this.shuttingDown = true;
+    console.log("[Daemon] Shutting down...");
+    for (const [projectPath, connection] of this.connections) {
+      if (connection.reconnectTimer) {
+        clearTimeout(connection.reconnectTimer);
+      }
+      await connection.client.disconnect();
+    }
+    this.connections.clear();
+    if (this.identityServer) {
+      await this.identityServer.stop();
+      this.identityServer = null;
+    }
+    await this.ipcServer.stop();
+    console.log("[Daemon] Shutdown complete");
+  }
+  /**
+   * EP613: Clean up PID file and exit gracefully
+   * Called when user explicitly requests disconnect
+   */
+  async cleanupAndExit() {
+    await this.shutdown();
+    try {
+      const pidPath = getPidFilePath();
+      if (fs5.existsSync(pidPath)) {
+        fs5.unlinkSync(pidPath);
+        console.log("[Daemon] PID file cleaned up");
+      }
+    } catch (error) {
+      console.error("[Daemon] Failed to clean up PID file:", error);
+    }
+    console.log("[Daemon] Exiting...");
+    process.exit(0);
+  }
+};
+async function main() {
+  if (!process.env.EPISODA_DAEMON_MODE) {
+    console.error("This script should only be run by daemon-manager");
+    process.exit(1);
+  }
+  const daemon = new Daemon();
+  await daemon.start();
+  await new Promise(() => {
+  });
+}
+main().catch((error) => {
+  console.error("[Daemon] Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=daemon-process.js.map