episoda 0.2.3 → 0.2.7

package/dist/index.js

@@ -1,102 +1,3758 @@
 #!/usr/bin/env node
+#!/usr/bin/env node
 "use strict";
-/**
- * Episoda CLI
- *
- * Local development workflow orchestration for episoda.dev
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const core_1 = require("./core");
-const dev_1 = require("./commands/dev");
-const auth_1 = require("./commands/auth");
-const status_1 = require("./commands/status");
-const stop_1 = require("./commands/stop");
-const output_1 = require("./output");
-commander_1.program
-    .name('episoda')
-    .description('Episoda local development workflow orchestration')
-    .version(core_1.VERSION);
-// Auth command (K722)
-commander_1.program
-    .command('auth')
-    .description('Authenticate to Episoda via OAuth and configure CLI')
-    .option('--api-url <url>', 'API URL (default: https://episoda.dev)')
-    .action(async (options) => {
-    try {
-        await (0, auth_1.authCommand)(options);
+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 };
     }
-    catch (error) {
-        output_1.status.error(`Authentication failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
+    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, "");
+      });
+    }
+  }
 });
-// Dev command
-commander_1.program
-    .command('dev')
-    .description('Start dev server with Episoda orchestration')
-    .option('--auto-restart', 'Auto-restart dev server if it crashes')
-    .option('--connection-only', 'Connection-only mode (don\'t start dev server)')
-    .allowUnknownOption()
-    .action(async (options, cmd) => {
-    try {
-        // Extract command after 'dev' as the dev server command
-        // e.g., 'episoda dev -- npm run dev' -> ["npm", "run", "dev"]
-        const args = process.argv.slice(process.argv.indexOf('dev') + 1);
-        // Remove '--' separator if present
-        const separatorIndex = args.indexOf('--');
-        const command = separatorIndex >= 0 ? args.slice(separatorIndex + 1) : [];
-        // Filter out our own options
-        const filteredCommand = command.filter(arg => arg !== '--auto-restart' && arg !== '--connection-only');
-        await (0, dev_1.devCommand)({
-            command: options.connectionOnly ? [] : (filteredCommand.length > 0 ? filteredCommand : undefined),
-            autoRestart: options.autoRestart
+
+// ../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 status2 = line.substring(0, 2);
+          const filePath = line.substring(3).trim();
+          if (status2.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 GitExecutor = 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 fs5 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const rebaseMergePath = `${gitDirPath}/rebase-merge`;
+            const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
+            try {
+              await fs5.access(rebaseMergePath);
+              inRebase = true;
+            } catch {
+              try {
+                await fs5.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 = GitExecutor;
+  }
+});
+
+// ../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 packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"));
+    exports2.VERSION = packageJson.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 EpisodaClient = 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 = EpisodaClient;
+  }
+});
+
+// ../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 = getConfigDir4;
+    exports2.getConfigPath = getConfigPath3;
+    exports2.loadConfig = loadConfig3;
+    exports2.saveConfig = saveConfig3;
+    exports2.validateToken = validateToken;
+    var fs5 = __importStar(require("fs"));
+    var path7 = __importStar(require("path"));
+    var os3 = __importStar(require("os"));
+    var child_process_1 = require("child_process");
+    var DEFAULT_CONFIG_FILE = "config.json";
+    function getConfigDir4() {
+      return process.env.EPISODA_CONFIG_DIR || path7.join(os3.homedir(), ".episoda");
     }
-    catch (error) {
-        output_1.status.error(`Dev command failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
+    function getConfigPath3(configPath) {
+      if (configPath) {
+        return configPath;
+      }
+      return path7.join(getConfigDir4(), DEFAULT_CONFIG_FILE);
+    }
+    function ensureConfigDir(configPath) {
+      const dir = path7.dirname(configPath);
+      const isNew = !fs5.existsSync(dir);
+      if (isNew) {
+        fs5.mkdirSync(dir, { recursive: true, mode: 448 });
+      }
+      if (process.platform === "darwin") {
+        const nosyncPath = path7.join(dir, ".nosync");
+        if (isNew || !fs5.existsSync(nosyncPath)) {
+          try {
+            fs5.writeFileSync(nosyncPath, "", { mode: 384 });
+            (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
+              stdio: "ignore",
+              timeout: 5e3
+            });
+          } catch {
+          }
+        }
+      }
+    }
+    async function loadConfig3(configPath) {
+      const fullPath = getConfigPath3(configPath);
+      if (!fs5.existsSync(fullPath)) {
+        return null;
+      }
+      try {
+        const content = fs5.readFileSync(fullPath, "utf8");
+        const config = JSON.parse(content);
+        return config;
+      } catch (error) {
+        console.error("Error loading config:", error);
+        return null;
+      }
+    }
+    async function saveConfig3(config, configPath) {
+      const fullPath = getConfigPath3(configPath);
+      ensureConfigDir(fullPath);
+      try {
+        const content = JSON.stringify(config, null, 2);
+        fs5.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);
     }
+  }
 });
-// Status command
-commander_1.program
-    .command('status')
-    .description('Show connection status')
-    .action(async () => {
+
+// ../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;
+    } });
+  }
+});
+
+// src/index.ts
+var import_commander = require("commander");
+var import_core7 = __toESM(require_dist());
+
+// src/commands/dev.ts
+var import_core3 = __toESM(require_dist());
+
+// src/framework-detector.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+async function detectFramework(cwd = process.cwd()) {
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const scripts = packageJson.scripts || {};
+    if (packageJson.dependencies?.next || packageJson.devDependencies?.next) {
+      if (scripts.dev) {
+        return {
+          framework: "Next.js",
+          command: ["npm", "run", "dev"],
+          confidence: "high",
+          detectedFrom: "package.json (next dependency + dev script)"
+        };
+      }
+      return {
+        framework: "Next.js",
+        command: ["npx", "next", "dev"],
+        confidence: "medium",
+        detectedFrom: "package.json (next dependency)"
+      };
+    }
+    if (packageJson.dependencies?.react || packageJson.devDependencies?.react) {
+      if (scripts.dev) {
+        return {
+          framework: "React",
+          command: ["npm", "run", "dev"],
+          confidence: "high",
+          detectedFrom: "package.json (react + dev script)"
+        };
+      }
+      if (scripts.start) {
+        return {
+          framework: "React",
+          command: ["npm", "start"],
+          confidence: "high",
+          detectedFrom: "package.json (react + start script)"
+        };
+      }
+    }
+    if (packageJson.dependencies?.express) {
+      if (scripts.dev) {
+        return {
+          framework: "Express",
+          command: ["npm", "run", "dev"],
+          confidence: "high",
+          detectedFrom: "package.json (express + dev script)"
+        };
+      }
+      if (scripts.start) {
+        return {
+          framework: "Express",
+          command: ["npm", "start"],
+          confidence: "medium",
+          detectedFrom: "package.json (express + start script)"
+        };
+      }
+    }
+    if (packageJson.dependencies?.vue || packageJson.devDependencies?.vue) {
+      if (scripts.dev) {
+        return {
+          framework: "Vue",
+          command: ["npm", "run", "dev"],
+          confidence: "high",
+          detectedFrom: "package.json (vue + dev script)"
+        };
+      }
+      if (scripts.serve) {
+        return {
+          framework: "Vue",
+          command: ["npm", "run", "serve"],
+          confidence: "high",
+          detectedFrom: "package.json (vue + serve script)"
+        };
+      }
+    }
+    if (scripts.dev) {
+      return {
+        framework: "Node.js",
+        command: ["npm", "run", "dev"],
+        confidence: "medium",
+        detectedFrom: "package.json (dev script)"
+      };
+    }
+    if (scripts.start) {
+      return {
+        framework: "Node.js",
+        command: ["npm", "start"],
+        confidence: "low",
+        detectedFrom: "package.json (start script)"
+      };
+    }
+  }
+  const requirementsPath = path.join(cwd, "requirements.txt");
+  if (fs.existsSync(requirementsPath)) {
+    const requirements = fs.readFileSync(requirementsPath, "utf-8");
+    if (requirements.includes("Django") || requirements.includes("django")) {
+      const managePy = path.join(cwd, "manage.py");
+      if (fs.existsSync(managePy)) {
+        return {
+          framework: "Django",
+          command: ["python", "manage.py", "runserver"],
+          confidence: "high",
+          detectedFrom: "requirements.txt (Django) + manage.py"
+        };
+      }
+      return {
+        framework: "Django",
+        command: ["python", "manage.py", "runserver"],
+        confidence: "medium",
+        detectedFrom: "requirements.txt (Django)"
+      };
+    }
+    if (requirements.includes("Flask") || requirements.includes("flask")) {
+      const appFiles = ["app.py", "application.py", "wsgi.py"];
+      for (const file of appFiles) {
+        if (fs.existsSync(path.join(cwd, file))) {
+          return {
+            framework: "Flask",
+            command: ["flask", "run"],
+            confidence: "high",
+            detectedFrom: `requirements.txt (Flask) + ${file}`
+          };
+        }
+      }
+      return {
+        framework: "Flask",
+        command: ["flask", "run"],
+        confidence: "medium",
+        detectedFrom: "requirements.txt (Flask)"
+      };
+    }
+    if (requirements.includes("fastapi") || requirements.includes("uvicorn")) {
+      return {
+        framework: "FastAPI",
+        command: ["uvicorn", "main:app", "--reload"],
+        confidence: "medium",
+        detectedFrom: "requirements.txt (fastapi/uvicorn)"
+      };
+    }
+  }
+  const gemfilePath = path.join(cwd, "Gemfile");
+  if (fs.existsSync(gemfilePath)) {
+    const gemfile = fs.readFileSync(gemfilePath, "utf-8");
+    if (gemfile.includes("rails")) {
+      return {
+        framework: "Rails",
+        command: ["rails", "server"],
+        confidence: "high",
+        detectedFrom: "Gemfile (rails)"
+      };
+    }
+    if (gemfile.includes("sinatra")) {
+      return {
+        framework: "Sinatra",
+        command: ["ruby", "app.rb"],
+        confidence: "medium",
+        detectedFrom: "Gemfile (sinatra)"
+      };
+    }
+  }
+  const goModPath = path.join(cwd, "go.mod");
+  if (fs.existsSync(goModPath)) {
+    return {
+      framework: "Go",
+      command: ["go", "run", "."],
+      confidence: "medium",
+      detectedFrom: "go.mod"
+    };
+  }
+  const cargoTomlPath = path.join(cwd, "Cargo.toml");
+  if (fs.existsSync(cargoTomlPath)) {
+    return {
+      framework: "Rust",
+      command: ["cargo", "run"],
+      confidence: "medium",
+      detectedFrom: "Cargo.toml"
+    };
+  }
+  return null;
+}
+async function resolveDevCommand(providedCommand, cwd = process.cwd()) {
+  if (providedCommand && providedCommand.length > 0) {
+    return { command: providedCommand, detection: null };
+  }
+  const detection = await detectFramework(cwd);
+  if (detection) {
+    return { command: detection.command, detection };
+  }
+  return {
+    command: ["npm", "run", "dev"],
+    detection: {
+      framework: "Unknown",
+      command: ["npm", "run", "dev"],
+      confidence: "low",
+      detectedFrom: "default fallback"
+    }
+  };
+}
+
+// src/output.ts
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var status = {
+  success: (message) => console.log(import_chalk.default.green("\u2713"), message),
+  error: (message) => console.log(import_chalk.default.red("\u2717"), message),
+  warning: (message) => console.log(import_chalk.default.yellow("\u26A0"), message),
+  info: (message) => console.log(import_chalk.default.blue("\u2139"), message),
+  debug: (message) => {
+    if (process.env.DEBUG) {
+      console.log(import_chalk.default.gray("\u2699"), import_chalk.default.gray(message));
+    }
+  },
+  // EP606: Progress indicator that overwrites the current line
+  progress: (message) => {
+    process.stdout.write(`\r${import_chalk.default.blue("\u23F3")} ${message}`);
+  }
+};
+function printFrameworkDetection(framework, command, confidence) {
+  console.log(import_chalk.default.bold("\n\u{1F50D} Framework Detection"));
+  console.log(import_chalk.default.cyan("  Framework:"), framework);
+  console.log(import_chalk.default.cyan("  Command:"), command.join(" "));
+  console.log(import_chalk.default.cyan("  Confidence:"), confidence);
+  console.log();
+}
+
+// src/daemon/daemon-manager.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var import_child_process = require("child_process");
+var import_core = __toESM(require_dist());
+function killAllEpisodaProcesses() {
+  const currentPid = process.pid;
+  let killedCount = 0;
+  if (process.platform === "win32") {
+    console.warn("[Cleanup] Process cleanup not supported on Windows - skipping");
+    return 0;
+  }
+  try {
+    const psOutput = (0, import_child_process.execSync)(
+      'ps aux | grep -E "(episoda (dev|status|stop)|daemon-process\\.js|node ws-server\\.js)" | grep -v grep || true',
+      { encoding: "utf-8", timeout: 5e3 }
+    );
+    const lines = psOutput.trim().split("\n").filter((line) => line.length > 0);
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 2) continue;
+      const pid = parseInt(parts[1], 10);
+      if (isNaN(pid) || pid === currentPid) continue;
+      try {
+        process.kill(pid, "SIGTERM");
+        killedCount++;
+        console.log(`[Cleanup] Killed stale process PID ${pid}`);
+      } catch (err) {
+      }
+    }
+    if (killedCount > 0) {
+      (0, import_child_process.execSync)("sleep 0.5", { timeout: 2e3 });
+    }
+    const configDir = (0, import_core.getConfigDir)();
+    const pidPath = path2.join(configDir, "daemon.pid");
+    const sockPath = path2.join(configDir, "daemon.sock");
+    if (fs2.existsSync(pidPath)) {
+      fs2.unlinkSync(pidPath);
+    }
+    if (fs2.existsSync(sockPath)) {
+      fs2.unlinkSync(sockPath);
+    }
+  } catch (error) {
+    console.warn("[Cleanup] Error during process cleanup:", error instanceof Error ? error.message : error);
+  }
+  return killedCount;
+}
+function getPidFilePath() {
+  return path2.join((0, import_core.getConfigDir)(), "daemon.pid");
+}
+function isDaemonRunning() {
+  const pidPath = getPidFilePath();
+  try {
+    if (!fs2.existsSync(pidPath)) {
+      return null;
+    }
+    const pidStr = fs2.readFileSync(pidPath, "utf-8").trim();
+    const pid = parseInt(pidStr, 10);
+    if (isNaN(pid)) {
+      fs2.unlinkSync(pidPath);
+      return null;
+    }
     try {
-        await (0, status_1.statusCommand)();
+      process.kill(pid, 0);
+      return pid;
+    } catch (error) {
+      fs2.unlinkSync(pidPath);
+      return null;
+    }
+  } catch (error) {
+    console.error("Error checking daemon status:", error);
+    return null;
+  }
+}
+async function startDaemon() {
+  const existingPid = isDaemonRunning();
+  if (existingPid) {
+    throw new Error(`Daemon already running (PID: ${existingPid})`);
+  }
+  const configDir = (0, import_core.getConfigDir)();
+  if (!fs2.existsSync(configDir)) {
+    fs2.mkdirSync(configDir, { recursive: true });
+  }
+  const daemonScript = path2.join(__dirname, "daemon-process.js");
+  if (!fs2.existsSync(daemonScript)) {
+    throw new Error(`Daemon script not found: ${daemonScript}. Make sure CLI is built.`);
+  }
+  const child = (0, import_child_process.spawn)("node", [daemonScript], {
+    detached: true,
+    // Run independently of parent
+    stdio: "ignore",
+    // Don't inherit stdio (prevents hanging)
+    env: {
+      ...process.env,
+      EPISODA_DAEMON_MODE: "1"
+      // Signal to daemon it's running in daemon mode
+    }
+  });
+  child.unref();
+  const pid = child.pid;
+  const pidPath = getPidFilePath();
+  fs2.writeFileSync(pidPath, pid.toString(), "utf-8");
+  await new Promise((resolve2) => setTimeout(resolve2, 500));
+  const runningPid = isDaemonRunning();
+  if (!runningPid) {
+    throw new Error("Daemon failed to start");
+  }
+  return pid;
+}
+async function stopDaemon(timeout = 5e3) {
+  const pid = isDaemonRunning();
+  if (!pid) {
+    const pidPath = getPidFilePath();
+    if (fs2.existsSync(pidPath)) {
+      fs2.unlinkSync(pidPath);
     }
-    catch (error) {
-        output_1.status.error(`Status check failed: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      try {
+        process.kill(pid, 0);
+        await new Promise((resolve2) => setTimeout(resolve2, 100));
+      } catch (error) {
+        const pidPath2 = getPidFilePath();
+        if (fs2.existsSync(pidPath2)) {
+          fs2.unlinkSync(pidPath2);
+        }
+        return true;
+      }
+    }
+    console.warn(`Daemon didn't stop gracefully, forcing shutdown (PID: ${pid})`);
+    process.kill(pid, "SIGKILL");
+    const pidPath = getPidFilePath();
+    if (fs2.existsSync(pidPath)) {
+      fs2.unlinkSync(pidPath);
+    }
+    return true;
+  } catch (error) {
+    console.error("Error stopping daemon:", error);
+    return false;
+  }
+}
+
+// src/ipc/ipc-client.ts
+var net = __toESM(require("net"));
+var path3 = __toESM(require("path"));
+var crypto = __toESM(require("crypto"));
+var import_core2 = __toESM(require_dist());
+var getSocketPath = () => path3.join((0, import_core2.getConfigDir)(), "daemon.sock");
+var DEFAULT_TIMEOUT = 15e3;
+async function sendCommand(command, params, timeout = DEFAULT_TIMEOUT) {
+  return new Promise((resolve2, reject) => {
+    const socket = net.createConnection(getSocketPath());
+    const requestId = crypto.randomUUID();
+    let buffer = "";
+    let timeoutHandle;
+    timeoutHandle = setTimeout(() => {
+      socket.destroy();
+      reject(new Error(`Command timed out after ${timeout}ms`));
+    }, timeout);
+    socket.on("connect", () => {
+      const request = {
+        id: requestId,
+        command,
+        params
+      };
+      socket.write(JSON.stringify(request) + "\n");
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) return;
+      const message = buffer.slice(0, newlineIndex);
+      try {
+        const response = JSON.parse(message);
+        if (response.id !== requestId) {
+          reject(new Error("Response ID mismatch"));
+          return;
+        }
+        clearTimeout(timeoutHandle);
+        socket.end();
+        if (response.success) {
+          resolve2(response.data);
+        } else {
+          reject(new Error(response.error || "Command failed"));
+        }
+      } catch (error) {
+        clearTimeout(timeoutHandle);
+        socket.end();
+        reject(new Error("Invalid response from daemon"));
+      }
+    });
+    socket.on("error", (error) => {
+      clearTimeout(timeoutHandle);
+      if (error.code === "ENOENT" || error.code === "ECONNREFUSED") {
+        reject(new Error("Daemon is not running. Start it with: episoda dev"));
+      } else {
+        reject(error);
+      }
+    });
+    socket.on("timeout", () => {
+      clearTimeout(timeoutHandle);
+      socket.destroy();
+      reject(new Error("Connection timeout"));
+    });
+  });
+}
+async function isDaemonReachable() {
+  try {
+    await sendCommand("ping", {}, 1e3);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+async function addProject(projectId, projectPath) {
+  return await sendCommand("add-project", { projectId, projectPath }, 3e4);
+}
+async function getStatus() {
+  return await sendCommand("status");
+}
+async function shutdownDaemon() {
+  await sendCommand("shutdown", {}, 2e3);
+}
+async function verifyHealth() {
+  return await sendCommand("verify-health");
+}
+
+// src/commands/dev.ts
+var import_child_process2 = require("child_process");
+var path4 = __toESM(require("path"));
+
+// src/utils/port-check.ts
+var net2 = __toESM(require("net"));
+async function isPortInUse(port) {
+  return new Promise((resolve2) => {
+    const server = net2.createServer();
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve2(true);
+      } else {
+        resolve2(false);
+      }
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve2(false);
+    });
+    server.listen(port);
+  });
+}
+function getServerPort() {
+  if (process.env.PORT) {
+    return parseInt(process.env.PORT, 10);
+  }
+  return 3e3;
+}
+
+// src/commands/dev.ts
+var CONNECTION_MAX_RETRIES = 3;
+function findGitRoot(startDir) {
+  try {
+    const result = (0, import_child_process2.execSync)("git rev-parse --show-toplevel", {
+      cwd: startDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+async function devCommand(options = {}) {
+  try {
+    const config = await (0, import_core3.loadConfig)();
+    if (!config || !config.access_token || !config.project_id) {
+      status.error("No authentication found. Please run:");
+      status.info("");
+      status.info("  episoda auth");
+      status.info("");
+      status.info("This will authenticate with episoda.dev and configure the CLI.");
+      process.exit(1);
+    }
+    const killedCount = killAllEpisodaProcesses();
+    if (killedCount > 0) {
+      status.info(`Cleaned up ${killedCount} stale process${killedCount > 1 ? "es" : ""}`);
+    }
+    const serverUrl = config.api_url || process.env.EPISODA_API_URL || "https://episoda.dev";
+    let projectPath;
+    const SETTINGS_CACHE_TTL = 24 * 60 * 60 * 1e3;
+    const cachedSettings = config.project_settings;
+    const isCacheFresh = cachedSettings?.cached_at && Date.now() - cachedSettings.cached_at < SETTINGS_CACHE_TTL;
+    if (isCacheFresh && cachedSettings?.local_project_path) {
+      projectPath = cachedSettings.local_project_path;
+      status.debug(`Using cached project path: ${projectPath}`);
+    } else {
+      const detectedRoot = findGitRoot(options.cwd || process.cwd());
+      projectPath = detectedRoot || path4.resolve(options.cwd || process.cwd());
+      if (detectedRoot) {
+        status.debug(`Detected project root: ${projectPath}`);
+      } else {
+        status.warning(`Could not detect git root, using: ${projectPath}`);
+      }
+      const updatedConfig = {
+        ...config,
+        project_settings: {
+          ...cachedSettings,
+          local_project_path: projectPath,
+          cached_at: Date.now()
+        }
+      };
+      await (0, import_core3.saveConfig)(updatedConfig);
+      status.debug("Cached project settings locally");
+      const settingsUrl = `${serverUrl}/api/projects/${config.project_id}/settings`;
+      fetch(settingsUrl, {
+        method: "PATCH",
+        headers: {
+          "Authorization": `Bearer ${config.access_token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ local_project_path: projectPath })
+      }).catch(() => {
+      });
+    }
+    let daemonPid = isDaemonRunning();
+    if (!daemonPid) {
+      status.info("Starting Episoda daemon...");
+      try {
+        daemonPid = await startDaemon();
+        status.success(`Daemon started (PID: ${daemonPid})`);
+      } catch (error) {
+        status.error(`Failed to start daemon: ${error instanceof Error ? error.message : String(error)}`);
         process.exit(1);
+      }
+    } else {
+      status.debug(`Daemon already running (PID: ${daemonPid})`);
     }
-});
-// Stop command (K722)
-commander_1.program
-    .command('stop')
-    .description('Stop the Episoda daemon')
-    .option('--force', 'Force kill daemon without graceful shutdown')
-    .action(async (options) => {
+    const reachable = await isDaemonReachable();
+    if (!reachable) {
+      status.error("Daemon is running but not responding. Try: episoda stop && episoda dev");
+      process.exit(1);
+    }
+    status.info(`Connecting project to Episoda...`);
+    let connected = false;
+    let lastError;
+    for (let retry = 0; retry < CONNECTION_MAX_RETRIES && !connected; retry++) {
+      if (retry > 0) {
+        status.info(`Retrying connection (attempt ${retry + 1}/${CONNECTION_MAX_RETRIES})...`);
+        await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+      }
+      try {
+        const result = await addProject(config.project_id, projectPath);
+        if (result.connected) {
+          connected = true;
+        } else {
+          lastError = result.error || "Connection failed";
+        }
+      } catch (error) {
+        lastError = error instanceof Error ? error.message : String(error);
+      }
+    }
+    if (!connected) {
+      status.error(`Failed to connect: ${lastError}`);
+      status.info("Check server status at https://episoda.dev/api/system/health");
+      process.exit(1);
+    }
+    status.success("Connected to Episoda");
+    let command;
+    let detection;
+    let connectionOnlyMode = false;
+    if (options.command && options.command.length === 0) {
+      connectionOnlyMode = true;
+      status.debug("Connection-only mode (explicit)");
+    } else if (!options.command) {
+      const serverPort = getServerPort();
+      const portInUse = await isPortInUse(serverPort);
+      if (portInUse) {
+        connectionOnlyMode = true;
+        status.info(`Server already running on port ${serverPort}`);
+        status.info("Connecting to existing server...");
+      }
+    }
+    if (!connectionOnlyMode) {
+      try {
+        const result = await resolveDevCommand(options.command || null, projectPath);
+        command = result.command;
+        detection = result.detection;
+        if (detection && !options.command) {
+          printFrameworkDetection(detection.framework, detection.command, detection.confidence);
+        }
+      } catch (error) {
+        status.debug("No dev command detected");
+        command = void 0;
+      }
+    }
+    if (command && command.length > 0) {
+      await runDevServer(command, projectPath, options.autoRestart ?? false);
+    } else {
+      status.info("");
+      status.info("Connected! Git operations will be executed by Episoda.");
+      status.info("Press Ctrl+C to disconnect.");
+      status.info("");
+      await new Promise(() => {
+      });
+    }
+  } catch (error) {
+    status.error(`Failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+async function runDevServer(command, cwd, autoRestart) {
+  let devProcess;
+  let restartCount = 0;
+  let shuttingDown = false;
+  const startServer = () => {
+    status.info(`Starting dev server: ${command.join(" ")}`);
+    devProcess = (0, import_child_process2.spawn)(command[0], command.slice(1), {
+      cwd,
+      stdio: ["inherit", "inherit", "inherit"],
+      shell: true
+    });
+    devProcess.on("exit", (code, signal) => {
+      if (shuttingDown) {
+        status.info("Dev server stopped");
+        return;
+      }
+      if (code === 0) {
+        status.success("Dev server exited successfully");
+      } else {
+        status.error(`Dev server exited with code ${code}${signal ? ` (signal: ${signal})` : ""}`);
+      }
+      if (autoRestart && !shuttingDown) {
+        restartCount++;
+        status.info(`Auto-restarting dev server (attempt ${restartCount})...`);
+        setTimeout(() => {
+          startServer();
+        }, 2e3);
+      }
+    });
+    devProcess.on("error", (error) => {
+      status.error(`Dev server error: ${error.message}`);
+    });
+  };
+  const shutdownHandler = async (signal) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    status.info(`
+Received ${signal}, shutting down...`);
+    if (devProcess) {
+      devProcess.kill("SIGTERM");
+    }
+    status.info("Dev server stopped. Daemon continues running in background.");
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdownHandler("SIGTERM"));
+  process.on("SIGINT", () => shutdownHandler("SIGINT"));
+  startServer();
+  await new Promise(() => {
+  });
+}
+
+// src/commands/auth.ts
+var os2 = __toESM(require("os"));
+var fs4 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var import_child_process4 = require("child_process");
+var import_core5 = __toESM(require_dist());
+
+// src/daemon/machine-id.ts
+var os = __toESM(require("os"));
+var fs3 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var crypto2 = __toESM(require("crypto"));
+var import_child_process3 = require("child_process");
+var import_core4 = __toESM(require_dist());
+async function getMachineId() {
+  const machineIdPath = path5.join((0, import_core4.getConfigDir)(), "machine-id");
+  try {
+    if (fs3.existsSync(machineIdPath)) {
+      const machineId2 = fs3.readFileSync(machineIdPath, "utf-8").trim();
+      if (machineId2) {
+        return machineId2;
+      }
+    }
+  } catch (error) {
+  }
+  const machineId = generateMachineId();
+  try {
+    const dir = path5.dirname(machineIdPath);
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
+    }
+    fs3.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_process3.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 (fs3.existsSync("/etc/machine-id")) {
+        const machineId = fs3.readFileSync("/etc/machine-id", "utf-8").trim();
+        if (machineId && machineId.length > 0) {
+          return machineId;
+        }
+      }
+      if (fs3.existsSync("/var/lib/dbus/machine-id")) {
+        const dbusId = fs3.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_process3.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 crypto2.randomUUID();
+}
+function generateMachineId() {
+  const hostname2 = os.hostname();
+  const hwUUID = getHardwareUUID();
+  const shortId = hwUUID.replace(/-/g, "").slice(0, 8).toLowerCase();
+  return `${hostname2}-${shortId}`;
+}
+
+// src/git-helpers/git-credential-helper.ts
+function generateCredentialHelperScript(apiUrl) {
+  return `#!/bin/bash
+#
+# Episoda Git Credential Helper
+# EP548/EP612: Unified git authentication for all environments
+#
+# This script is called by git when credentials are needed.
+# It calls the Episoda API to get a fresh GitHub token.
+#
+# Installation: episoda auth
+# Location: ~/.episoda/bin/git-credential-episoda (local)
+#           /usr/local/bin/git-credential-episoda (cloud VM)
+#
+# Git credential protocol:
+# - git calls: git-credential-episoda get
+# - input on stdin: protocol=https\\nhost=github.com\\n
+# - output on stdout: username=x-access-token\\npassword=TOKEN\\n
+#
+# Dependencies: bash, curl (no jq required)
+#
+
+set -euo pipefail
+
+EPISODA_DIR="\${HOME}/.episoda"
+CONFIG_FILE="\${EPISODA_DIR}/config.json"
+CACHE_FILE="\${EPISODA_DIR}/git-token-cache.json"
+API_URL="${apiUrl}"
+
+# Cache TTL in seconds (5 minutes)
+CACHE_TTL=300
+
+# Log function (to stderr so git doesn't see it)
+log() {
+  if [[ "\${GIT_CREDENTIAL_EPISODA_DEBUG:-}" == "1" ]]; then
+    echo "[episoda-git] $(date '+%H:%M:%S') $*" >&2
+  fi
+}
+
+# Error log (always shown)
+error() {
+  echo "[episoda-git] ERROR: $*" >&2
+}
+
+# Pure bash JSON value extraction (no jq needed)
+# Usage: json_get '{"foo":"bar"}' "foo" -> "bar"
+# Handles simple flat JSON and nested paths like "credentials.username"
+json_get() {
+  local json="$1"
+  local key="$2"
+  local value=""
+
+  # Handle nested keys (e.g., "credentials.username")
+  if [[ "$key" == *.* ]]; then
+    local outer="\${key%%.*}"
+    local inner="\${key#*.}"
+    # Extract outer object first, then inner key
+    # Match "outer":{...} and extract the {...} part
+    local nested
+    nested=$(echo "$json" | sed -n 's/.*"'$outer'"[[:space:]]*:[[:space:]]*{\\([^}]*\\)}.*/\\1/p')
+    if [[ -n "$nested" ]]; then
+      json_get "{$nested}" "$inner"
+      return
+    fi
+    return
+  fi
+
+  # Simple key extraction: "key":"value" or "key": "value"
+  # Handle both quoted strings and unquoted values
+  value=$(echo "$json" | sed -n 's/.*"'$key'"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/p')
+
+  if [[ -n "$value" ]]; then
+    echo "$value"
+  fi
+}
+
+# Check for required dependencies
+check_dependencies() {
+  if ! command -v curl >/dev/null 2>&1; then
+    error "curl is required but not installed"
+    return 1
+  fi
+  return 0
+}
+
+# Parse git credential input from stdin
+parse_input() {
+  while IFS= read -r line; do
+    [[ -z "$line" ]] && break
+    case "$line" in
+      protocol=*) PROTOCOL="\${line#protocol=}" ;;
+      host=*) HOST="\${line#host=}" ;;
+      path=*) PATH_="\${line#path=}" ;;
+    esac
+  done
+}
+
+# Parse ISO 8601 date to unix timestamp (cross-platform)
+parse_iso_date() {
+  local iso_date="$1"
+  # Try GNU date first (Linux)
+  if date -d "$iso_date" +%s 2>/dev/null; then
+    return
+  fi
+  # Try BSD date (macOS) - strip timezone for parsing
+  local clean_date="\${iso_date%+*}"  # Remove +00:00
+  clean_date="\${clean_date%Z}"       # Remove Z
+  clean_date="\${clean_date%.*}"      # Remove .milliseconds
+  if date -jf "%Y-%m-%dT%H:%M:%S" "$clean_date" +%s 2>/dev/null; then
+    return
+  fi
+  # Fallback: return 0 (expired)
+  echo "0"
+}
+
+# Check if cached token is still valid
+get_cached_token() {
+  if [[ ! -f "$CACHE_FILE" ]]; then
+    log "No cache file"
+    return 1
+  fi
+
+  # Read cache file
+  local cache_content
+  cache_content=$(cat "$CACHE_FILE" 2>/dev/null) || return 1
+
+  # Parse cache file using pure bash
+  local expires_at
+  expires_at=$(json_get "$cache_content" "expires_at")
+
+  if [[ -z "$expires_at" ]]; then
+    log "No expires_at in cache"
+    return 1
+  fi
+
+  # Check if expired (with 60 second buffer)
+  local now expires_ts buffer
+  now=$(date +%s)
+  expires_ts=$(parse_iso_date "$expires_at")
+  buffer=60
+
+  if [[ $((expires_ts - buffer)) -le $now ]]; then
+    log "Cache expired (expires: $expires_at)"
+    return 1
+  fi
+
+  # Return cached token
+  CACHED_TOKEN=$(json_get "$cache_content" "password")
+  CACHED_USER=$(json_get "$cache_content" "username")
+
+  if [[ -n "$CACHED_TOKEN" && -n "$CACHED_USER" ]]; then
+    log "Using cached token (expires: $expires_at)"
+    return 0
+  fi
+
+  log "Invalid cache content"
+  return 1
+}
+
+# Save token to cache
+save_to_cache() {
+  local username="$1"
+  local password="$2"
+  local expires_at="$3"
+
+  mkdir -p "$EPISODA_DIR"
+  cat > "$CACHE_FILE" <<CACHE_EOF
+{"username":"$username","password":"$password","expires_at":"$expires_at","cached_at":"$(date -u +"%Y-%m-%dT%H:%M:%SZ")"}
+CACHE_EOF
+  chmod 600 "$CACHE_FILE"
+  log "Token cached until $expires_at"
+}
+
+# Get credentials from Episoda API
+fetch_credentials() {
+  local api_url="\${EPISODA_API_URL:-\${API_URL}}"
+  local response=""
+  local http_code=""
+
+  # Detect environment - check multiple ways to identify a cloud VM
+  local machine_id=""
+
+  # Check FLY_MACHINE_ID (set by Fly.io on all machines)
+  if [[ -n "\${FLY_MACHINE_ID:-}" ]]; then
+    machine_id="$FLY_MACHINE_ID"
+    log "Cloud environment detected via FLY_MACHINE_ID: $machine_id"
+  # Legacy: check /app/.machine_id file
+  elif [[ -f "/app/.machine_id" ]]; then
+    machine_id=$(cat /app/.machine_id)
+    log "Cloud environment detected via /app/.machine_id: $machine_id"
+  fi
+
+  if [[ -n "$machine_id" ]]; then
+    # Cloud VM: use machine ID header
+    log "Fetching credentials for machine: $machine_id"
+    response=$(curl -s -w "\\n%{http_code}" --max-time 10 "\${api_url}/api/git/credentials" \\
+      -H "X-Machine-ID: $machine_id" \\
+      -H "Content-Type: application/json" 2>&1) || {
+      error "curl failed: $response"
+      return 1
+    }
+  else
+    # Local: use OAuth token from config
+    if [[ ! -f "$CONFIG_FILE" ]]; then
+      error "No config found at $CONFIG_FILE. Run 'episoda auth' first."
+      return 1
+    fi
+
+    # Parse config using pure bash
+    local config_content
+    config_content=$(cat "$CONFIG_FILE" 2>/dev/null) || {
+      error "Cannot read config file"
+      return 1
+    }
+
+    local access_token project_id
+    access_token=$(json_get "$config_content" "access_token")
+    project_id=$(json_get "$config_content" "project_id")
+
+    if [[ -z "$access_token" ]]; then
+      error "No access token in config. Run 'episoda auth' to authenticate."
+      return 1
+    fi
+
+    log "Local environment (project: $project_id)"
+    response=$(curl -s -w "\\n%{http_code}" --max-time 10 "\${api_url}/api/git/credentials" \\
+      -H "Authorization: Bearer $access_token" \\
+      -H "X-Project-ID: $project_id" \\
+      -H "Content-Type: application/json" 2>&1) || {
+      error "curl failed: $response"
+      return 1
+    }
+  fi
+
+  # Split response and HTTP code
+  http_code=$(echo "$response" | tail -n1)
+  response=$(echo "$response" | sed '$d')
+
+  # Check HTTP status
+  if [[ "$http_code" != "200" ]]; then
+    error "API returned HTTP $http_code"
+    log "Response: $response"
+    return 1
+  fi
+
+  # Parse response using pure bash
+  CRED_USERNAME=$(json_get "$response" "credentials.username")
+  CRED_PASSWORD=$(json_get "$response" "credentials.password")
+  CRED_EXPIRES=$(json_get "$response" "credentials.expires_at")
+
+  if [[ -z "$CRED_USERNAME" || -z "$CRED_PASSWORD" ]]; then
+    error "Invalid credentials in response"
+    log "Response: $response"
+    return 1
+  fi
+
+  # Cache the token
+  save_to_cache "$CRED_USERNAME" "$CRED_PASSWORD" "$CRED_EXPIRES"
+
+  log "Credentials fetched successfully"
+  return 0
+}
+
+# Main
+main() {
+  local command="\${1:-}"
+
+  # Check dependencies before processing
+  if ! check_dependencies; then
+    exit 0  # Exit gracefully so git tries other helpers
+  fi
+
+  case "$command" in
+    get)
+      parse_input
+
+      # Only handle github.com
+      if [[ "\${HOST:-}" != "github.com" ]]; then
+        log "Not handling host: \${HOST:-unknown}"
+        exit 0
+      fi
+
+      # Try cache first
+      if get_cached_token; then
+        echo "username=$CACHED_USER"
+        echo "password=$CACHED_TOKEN"
+        exit 0
+      fi
+
+      # Fetch fresh credentials
+      if fetch_credentials; then
+        echo "username=$CRED_USERNAME"
+        echo "password=$CRED_PASSWORD"
+        exit 0
+      fi
+
+      # Failed - let git try other credential helpers
+      log "Failed to get credentials, falling back to other helpers"
+      exit 0
+      ;;
+
+    store|erase)
+      # We don't store or erase credentials
+      exit 0
+      ;;
+
+    *)
+      # Unknown command
+      exit 0
+      ;;
+  esac
+}
+
+main "$@"
+`;
+}
+var CREDENTIAL_HELPER_SCRIPT = generateCredentialHelperScript("https://episoda.dev");
+
+// src/commands/auth.ts
+async function authCommand(options = {}) {
+  const apiUrl = options.apiUrl || process.env.EPISODA_API_URL || "https://episoda.dev";
+  status.info("Initializing Episoda CLI...");
+  status.info("");
+  status.info("Step 1/3: Requesting authorization code...");
+  const deviceAuth = await initiateDeviceFlow(apiUrl);
+  status.success(`\u2713 Authorization code received: ${deviceAuth.user_code}`);
+  status.info("");
+  status.info("Step 2/3: Opening browser for authorization...");
+  status.info(`  Visit: ${deviceAuth.verification_uri_complete}`);
+  status.info(`  User code: ${deviceAuth.user_code}`);
+  status.info("");
+  openBrowser(deviceAuth.verification_uri_complete);
+  status.info("Waiting for authorization...");
+  const authorized = await monitorAuthorization(apiUrl, deviceAuth.device_code, deviceAuth.expires_in);
+  if (!authorized) {
+    throw new Error("Authorization failed or timed out");
+  }
+  status.success("\u2713 Authorization successful!");
+  status.info("");
+  status.info("Step 3/3: Exchanging authorization for access token...");
+  const machineId = await getMachineId();
+  const tokenResponse = await exchangeDeviceCode(apiUrl, deviceAuth.device_code, machineId);
+  status.success("\u2713 Access token received");
+  status.info(`  Project: ${tokenResponse.project_uid}`);
+  status.info(`  Workspace: ${tokenResponse.workspace_uid}`);
+  status.info("");
+  await (0, import_core5.saveConfig)({
+    project_id: tokenResponse.project_id,
+    user_id: tokenResponse.user_id,
+    workspace_id: tokenResponse.workspace_id,
+    access_token: tokenResponse.access_token,
+    api_url: apiUrl,
+    cli_version: import_core5.VERSION
+  });
+  status.success(`\u2713 Configuration saved to ${(0, import_core5.getConfigPath)()}`);
+  status.info("");
+  status.info("Installing git credential helper...");
+  const credentialHelperInstalled = await installGitCredentialHelper(apiUrl);
+  if (credentialHelperInstalled) {
+    status.success("\u2713 Git credential helper installed");
+    status.info("  Git operations will now use Episoda authentication automatically.");
+  } else {
+    status.warning("\u26A0 Git credential helper could not be installed automatically.");
+    status.info("  You can still use git with manual token setup.");
+  }
+  status.info("");
+  status.success("CLI initialized successfully!");
+  status.info("");
+  status.info("Next steps:");
+  status.info("  \u2022 Start daemon: episoda dev");
+  status.info("  \u2022 Check status: episoda status");
+  status.info("  \u2022 Git operations will use Episoda auth automatically");
+  status.info("");
+}
+async function initiateDeviceFlow(apiUrl) {
+  const response = await fetch(`${apiUrl}/api/oauth/code`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({})
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.error_description || error.error || "Failed to initiate device flow");
+  }
+  return await response.json();
+}
+async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
+  return new Promise((resolve2) => {
+    const timeout = setTimeout(() => {
+      status.error("Authorization timed out");
+      resolve2(false);
+    }, expiresIn * 1e3);
+    const url = `${apiUrl}/api/oauth/authorize-stream?device_code=${deviceCode}`;
+    const curlProcess = (0, import_child_process4.spawn)("curl", ["-N", url]);
+    let buffer = "";
+    curlProcess.stdout.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const messages = buffer.split("\n\n");
+      buffer = messages.pop() || "";
+      for (const message of messages) {
+        if (!message.trim()) continue;
+        const lines = message.split("\n");
+        let eventType = "";
+        let data = "";
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            eventType = line.substring(7);
+          } else if (line.startsWith("data: ")) {
+            data = line.substring(6);
+          }
+        }
+        if (!eventType) continue;
+        try {
+          if (eventType === "authorized") {
+            clearTimeout(timeout);
+            curlProcess.kill();
+            resolve2(true);
+            return;
+          } else if (eventType === "denied") {
+            clearTimeout(timeout);
+            curlProcess.kill();
+            status.error("Authorization denied by user");
+            resolve2(false);
+            return;
+          } else if (eventType === "expired") {
+            clearTimeout(timeout);
+            curlProcess.kill();
+            status.error("Authorization code expired");
+            resolve2(false);
+            return;
+          } else if (eventType === "error") {
+            const errorData = JSON.parse(data);
+            clearTimeout(timeout);
+            curlProcess.kill();
+            status.error(`Authorization error: ${errorData.error_description || errorData.error || "Unknown error"}`);
+            resolve2(false);
+            return;
+          }
+        } catch (error) {
+        }
+      }
+    });
+    curlProcess.on("error", (error) => {
+      clearTimeout(timeout);
+      status.error(`Failed to monitor authorization: ${error.message}`);
+      resolve2(false);
+    });
+    curlProcess.on("close", (code) => {
+      clearTimeout(timeout);
+      if (code !== 0 && code !== null) {
+        status.error(`Authorization monitoring failed with code ${code}`);
+        resolve2(false);
+      }
+    });
+  });
+}
+async function exchangeDeviceCode(apiUrl, deviceCode, machineId) {
+  const response = await fetch(`${apiUrl}/api/oauth/token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: deviceCode,
+      machine_id: machineId
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.error_description || error.error || "Failed to exchange device code");
+  }
+  const tokenResponse = await response.json();
+  if (!tokenResponse.access_token || !tokenResponse.user_id || !tokenResponse.workspace_id || !tokenResponse.project_id) {
+    throw new Error("Incomplete token response from server");
+  }
+  return tokenResponse;
+}
+function openBrowser(url) {
+  const platform2 = os2.platform();
+  let command;
+  let args;
+  switch (platform2) {
+    case "darwin":
+      command = "open";
+      args = [url];
+      break;
+    case "win32":
+      command = "cmd";
+      args = ["/c", "start", url];
+      break;
+    default:
+      command = "xdg-open";
+      args = [url];
+      break;
+  }
+  try {
+    (0, import_child_process4.spawn)(command, args, {
+      detached: true,
+      stdio: "ignore"
+    }).unref();
+  } catch (error) {
+    status.warning(`Could not open browser automatically. Please visit: ${url}`);
+  }
+}
+async function installGitCredentialHelper(apiUrl) {
+  try {
+    const homeDir = os2.homedir();
+    const episodaBinDir = path6.join(homeDir, ".episoda", "bin");
+    const helperPath = path6.join(episodaBinDir, "git-credential-episoda");
+    fs4.mkdirSync(episodaBinDir, { recursive: true });
+    const scriptContent = generateCredentialHelperScript(apiUrl);
+    fs4.writeFileSync(helperPath, scriptContent, { mode: 493 });
     try {
-        await (0, stop_1.stopCommand)(options);
+      fs4.accessSync(helperPath, fs4.constants.X_OK);
+    } catch {
     }
-    catch (error) {
-        output_1.status.error(`Stop failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
+    try {
+      const allHelpers = (0, import_child_process4.execSync)("git config --global --get-all credential.helper", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim().split("\n");
+      if (allHelpers.some((h) => h.includes(helperPath) || h.includes("git-credential-episoda"))) {
+        return true;
+      }
+    } catch {
     }
-});
-// Disconnect command (alias for stop)
-commander_1.program
-    .command('disconnect')
-    .description('Disconnect from episoda.dev (alias for stop)')
-    .action(async () => {
+    (0, import_child_process4.execSync)(`git config --global --add credential.helper "${helperPath}"`, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    updateShellProfile(episodaBinDir);
+    return true;
+  } catch (error) {
+    status.warning(`Could not install credential helper: ${error.message}`);
+    return false;
+  }
+}
+function updateShellProfile(binDir) {
+  const platform2 = os2.platform();
+  if (platform2 === "win32") {
+    return;
+  }
+  const homeDir = os2.homedir();
+  const profiles = [
+    path6.join(homeDir, ".bashrc"),
+    path6.join(homeDir, ".zshrc"),
+    path6.join(homeDir, ".profile")
+  ];
+  const exportLine = `export PATH="${binDir}:$PATH"  # Added by episoda auth`;
+  for (const profile of profiles) {
     try {
-        await (0, stop_1.stopCommand)();
+      if (fs4.existsSync(profile)) {
+        const content = fs4.readFileSync(profile, "utf8");
+        if (content.includes(".episoda/bin")) {
+          continue;
+        }
+        fs4.appendFileSync(profile, `
+# Episoda CLI
+${exportLine}
+`);
+      }
+    } catch {
+    }
+  }
+}
+
+// src/commands/status.ts
+var import_core6 = __toESM(require_dist());
+async function statusCommand(options = {}) {
+  status.info("Checking CLI status...");
+  status.info("");
+  const config = await (0, import_core6.loadConfig)();
+  if (!config) {
+    status.error("\u2717 CLI not initialized");
+    status.info("");
+    status.info("Run the following to initialize:");
+    status.info("  episoda init --project <project_id> --token <setup_token>");
+    status.info("");
+    status.info("Get a setup token from: Settings > Local Development");
+    return;
+  }
+  status.success("\u2713 CLI initialized");
+  status.info("");
+  status.info("Configuration:");
+  status.info(`  Project ID: ${config.project_id}`);
+  status.info(`  API URL: ${config.api_url}`);
+  status.info(`  CLI Version: ${config.cli_version}`);
+  status.info(`  Config file: ${(0, import_core6.getConfigPath)()}`);
+  status.info("");
+  if (!config.access_token || config.access_token === "") {
+    status.warning("\u26A0 Not authenticated");
+    status.info('  Run "episoda auth" to authenticate.');
+    return;
+  }
+  let daemonStatus = null;
+  try {
+    daemonStatus = await getStatus();
+  } catch {
+  }
+  if (!daemonStatus) {
+    status.warning("\u26A0 Daemon not running");
+    status.info('  Run "episoda dev" to start the daemon.');
+    return;
+  }
+  const connectedProject = daemonStatus.projects.find((p) => p.connected);
+  if (connectedProject) {
+    status.success("\u2713 Connected to server");
+    status.info(`  Device: ${daemonStatus.hostname}`);
+    status.info(`  Platform: ${daemonStatus.platform}/${daemonStatus.arch}`);
+    status.info(`  Project: ${connectedProject.name}`);
+  } else if (daemonStatus.projects.length > 0) {
+    status.warning("\u26A0 Daemon running but not connected");
+    status.info(`  Device: ${daemonStatus.hostname}`);
+    status.info(`  Platform: ${daemonStatus.platform}/${daemonStatus.arch}`);
+    status.info('  Run "episoda dev" in a project directory to connect.');
+  } else {
+    status.warning("\u26A0 Daemon running but no projects registered");
+    status.info(`  Device: ${daemonStatus.hostname}`);
+    status.info('  Run "episoda dev" in a project directory to connect.');
+  }
+  if (options.verify) {
+    status.info("");
+    status.info("Connection Health Check:");
+    try {
+      const health = await verifyHealth();
+      if (health.staleConnections > 0) {
+        status.warning(`  \u26A0 ${health.staleConnections} stale connection(s) detected`);
+        for (const project of health.projects) {
+          if (project.inConnectionsMap && !project.inLiveConnections) {
+            status.warning(`    - ${project.name}: in Map but WebSocket dead`);
+          }
+        }
+        status.info("  Stale connections will be cleaned up on next connect attempt.");
+      } else if (health.healthyConnections > 0) {
+        status.success(`  \u2713 All ${health.healthyConnections} connection(s) healthy`);
+      } else {
+        status.info("  No active connections to verify.");
+      }
+    } catch (error) {
+      status.error(`  \u2717 Health check failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+
+// src/commands/stop.ts
+async function stopCommand(options = {}) {
+  try {
+    const pid = isDaemonRunning();
+    if (!pid) {
+      status.info("Daemon is not running");
+      return;
     }
-    catch (error) {
-        output_1.status.error(`Disconnect failed: ${error instanceof Error ? error.message : String(error)}`);
+    status.info(`Stopping daemon (PID: ${pid})...`);
+    if (options.force) {
+      const stopped = await stopDaemon(1e3);
+      if (stopped) {
+        status.success("Daemon force-stopped");
+      } else {
+        status.error("Failed to stop daemon");
         process.exit(1);
+      }
+    } else {
+      try {
+        const reachable = await isDaemonReachable();
+        if (reachable) {
+          await shutdownDaemon();
+          status.success("Daemon stopped");
+        } else {
+          status.warning("Daemon not responding, forcing shutdown...");
+          const stopped = await stopDaemon(1e3);
+          if (stopped) {
+            status.success("Daemon stopped");
+          } else {
+            status.error("Failed to stop daemon");
+            process.exit(1);
+          }
+        }
+      } catch (error) {
+        status.warning("Failed to communicate with daemon, trying direct shutdown...");
+        const stopped = await stopDaemon(5e3);
+        if (stopped) {
+          status.success("Daemon stopped");
+        } else {
+          status.error(`Failed to stop daemon: ${error instanceof Error ? error.message : String(error)}`);
+          process.exit(1);
+        }
+      }
     }
+  } catch (error) {
+    status.error(`Failed to stop daemon: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+import_commander.program.name("episoda").description("Episoda local development workflow orchestration").version(import_core7.VERSION);
+import_commander.program.command("auth").description("Authenticate to Episoda via OAuth and configure CLI").option("--api-url <url>", "API URL (default: https://episoda.dev)").action(async (options) => {
+  try {
+    await authCommand(options);
+  } catch (error) {
+    status.error(`Authentication failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+import_commander.program.command("dev").description("Start dev server with Episoda orchestration").option("--auto-restart", "Auto-restart dev server if it crashes").option("--connection-only", "Connection-only mode (don't start dev server)").allowUnknownOption().action(async (options, cmd) => {
+  try {
+    const args = process.argv.slice(process.argv.indexOf("dev") + 1);
+    const separatorIndex = args.indexOf("--");
+    const command = separatorIndex >= 0 ? args.slice(separatorIndex + 1) : [];
+    const filteredCommand = command.filter((arg) => arg !== "--auto-restart" && arg !== "--connection-only");
+    await devCommand({
+      command: options.connectionOnly ? [] : filteredCommand.length > 0 ? filteredCommand : void 0,
+      autoRestart: options.autoRestart
+    });
+  } catch (error) {
+    status.error(`Dev command failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+import_commander.program.command("status").description("Show connection status").option("--verify", "Verify connection is healthy (not just connected)").action(async (options) => {
+  try {
+    await statusCommand({ verify: options.verify });
+  } catch (error) {
+    status.error(`Status check failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+import_commander.program.command("stop").description("Stop the Episoda daemon").option("--force", "Force kill daemon without graceful shutdown").action(async (options) => {
+  try {
+    await stopCommand(options);
+  } catch (error) {
+    status.error(`Stop failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+import_commander.program.command("disconnect").description("Disconnect from episoda.dev (alias for stop)").action(async () => {
+  try {
+    await stopCommand();
+  } catch (error) {
+    status.error(`Disconnect failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
 });
-commander_1.program.parse();
+import_commander.program.parse();
 //# sourceMappingURL=index.js.map