@arkhera30/cli 0.8.0 → 0.8.1

package/dist/index.js

@@ -1,4 +1,1155 @@
 #!/usr/bin/env node
+import { createRequire as __horusCreateRequire } from 'module'; const require = __horusCreateRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  __toESM,
+  require_claude_code_strategy,
+  require_claude_md_writer,
+  require_compiler,
+  require_composite_adapter,
+  require_core,
+  require_cursor_strategy,
+  require_errors,
+  require_filesystem_adapter,
+  require_forge_search_client,
+  require_global_claude_code_strategy,
+  require_global_config_loader,
+  require_http_adapter,
+  require_local_repo_state,
+  require_mcp_settings_writer,
+  require_merge_workspace_configs,
+  require_models,
+  require_path_utils,
+  require_registry,
+  require_repo_develop,
+  require_repo_errors,
+  require_repo_index_query,
+  require_repo_index_store,
+  require_repo_registry_client,
+  require_repo_scanner,
+  require_resolver,
+  require_session_cleanup,
+  require_session_list,
+  require_session_store,
+  require_url_utils,
+  require_workspace_creator,
+  require_workspace_lifecycle,
+  require_workspace_manager,
+  require_workspace_metadata_store
+} from "./chunk-6ROWQWZM.js";
+
+// ../forge/packages/core/dist/adapters/git-adapter.js
+var require_git_adapter = __commonJS({
+  "../forge/packages/core/dist/adapters/git-adapter.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.GitAdapter = void 0;
+    var child_process_1 = __require("child_process");
+    var util_1 = __require("util");
+    var crypto_1 = __require("crypto");
+    var fs_1 = __require("fs");
+    var path_1 = __importDefault(__require("path"));
+    var os_1 = __importDefault(__require("os"));
+    var filesystem_adapter_js_1 = require_filesystem_adapter();
+    var errors_js_1 = require_errors();
+    var execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+    var GitAdapter = class {
+      url;
+      ref;
+      registryPath;
+      sparse;
+      cacheDir;
+      tokenEnv;
+      delegate = null;
+      synced = false;
+      constructor(config) {
+        this.url = config.url;
+        this.ref = config.ref ?? "main";
+        this.registryPath = config.registryPath ?? "registry";
+        this.sparse = config.sparse;
+        this.tokenEnv = config.tokenEnv;
+        const baseCache = config.cacheDir ?? path_1.default.join(os_1.default.homedir(), ".forge", "cache", "git");
+        const repoHash = (0, crypto_1.createHash)("sha256").update(this.url).digest("hex").slice(0, 12);
+        this.cacheDir = path_1.default.join(baseCache, repoHash);
+      }
+      /**
+       * Returns the local cache directory path for this adapter.
+       * Useful for debugging and testing.
+       */
+      getCacheDir() {
+        return this.cacheDir;
+      }
+      // ---------------------------------------------------------------------------
+      // DataAdapter interface
+      // ---------------------------------------------------------------------------
+      async list(type) {
+        const delegate = await this.ensureCloned();
+        return delegate.list(type);
+      }
+      async read(type, id) {
+        const delegate = await this.ensureCloned();
+        return delegate.read(type, id);
+      }
+      async exists(type, id) {
+        const delegate = await this.ensureCloned();
+        return delegate.exists(type, id);
+      }
+      async write(type, id, bundle) {
+        const delegate = await this.ensureCloned();
+        return delegate.write(type, id, bundle);
+      }
+      async readResourceFile(type, id, relativePath) {
+        const delegate = await this.ensureCloned();
+        return delegate.readResourceFile(type, id, relativePath);
+      }
+      /**
+       * List all available semver versions for a specific artifact.
+       * Delegates to the underlying FilesystemAdapter's listVersions.
+       * Returns versions sorted descending (highest first).
+       * Returns empty array for flat layout artifacts or nonexistent artifacts.
+       */
+      async listVersions(type, id) {
+        const delegate = await this.ensureCloned();
+        return delegate.listVersions(type, id);
+      }
+      // ---------------------------------------------------------------------------
+      // Git operations
+      // ---------------------------------------------------------------------------
+      /**
+       * Ensure the repo is cloned/updated and return the FilesystemAdapter delegate.
+       */
+      async ensureCloned() {
+        if (this.delegate && this.synced) {
+          return this.delegate;
+        }
+        const exists = await this.cacheExists();
+        if (exists) {
+          await this.fetchAndCheckout();
+        } else {
+          await this.cloneRepo();
+        }
+        const registryRoot = path_1.default.join(this.cacheDir, this.registryPath);
+        this.delegate = new filesystem_adapter_js_1.FilesystemAdapter(registryRoot);
+        this.synced = true;
+        return this.delegate;
+      }
+      async cacheExists() {
+        try {
+          await fs_1.promises.access(path_1.default.join(this.cacheDir, ".git"));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      resolveUrl() {
+        if (!this.tokenEnv)
+          return this.url;
+        const token = process.env[this.tokenEnv];
+        if (!token) {
+          console.warn(`[GitAdapter] Token env var '${this.tokenEnv}' is not set. Falling back to unauthenticated access.`);
+          return this.url;
+        }
+        try {
+          const parsed = new URL(this.url);
+          parsed.username = token;
+          return parsed.toString();
+        } catch {
+          return this.url;
+        }
+      }
+      async cloneRepo() {
+        await fs_1.promises.mkdir(this.cacheDir, { recursive: true });
+        const cloneUrl = this.resolveUrl();
+        const args = ["clone", "--depth", "1", "--branch", this.ref, "--single-branch"];
+        if (this.sparse && this.sparse.length > 0) {
+          args.push("--sparse");
+        }
+        args.push(cloneUrl, this.cacheDir);
+        try {
+          await this.git(args, path_1.default.dirname(this.cacheDir));
+        } catch (err) {
+          throw new errors_js_1.AdapterError("GitAdapter", `Clone failed for ${this.url}: ${err.message}`, `Check that the URL is correct and you have access. If using HTTPS, set the tokenEnv config.`);
+        }
+        if (this.sparse && this.sparse.length > 0) {
+          try {
+            await this.git(["sparse-checkout", "set", ...this.sparse], this.cacheDir);
+          } catch (err) {
+            throw new errors_js_1.AdapterError("GitAdapter", `Sparse checkout config failed: ${err.message}`, `Check that the sparse paths are valid directories in the repository.`);
+          }
+        }
+      }
+      async fetchAndCheckout() {
+        try {
+          await this.git(["fetch", "--depth", "1", "origin", this.ref], this.cacheDir);
+          await this.git(["checkout", "FETCH_HEAD"], this.cacheDir);
+        } catch (err) {
+          throw new errors_js_1.AdapterError("GitAdapter", `Fetch/checkout failed for ${this.url} ref=${this.ref}: ${err.message}`, `Check that the ref '${this.ref}' exists in the repository and that you have network access.`);
+        }
+      }
+      async git(args, cwd) {
+        const { stdout } = await execFileAsync("git", args, {
+          cwd,
+          timeout: 3e4,
+          maxBuffer: 10 * 1024 * 1024
+          // 10MB
+        });
+        return stdout;
+      }
+    };
+    exports.GitAdapter = GitAdapter;
+  }
+});
+
+// ../forge/packages/core/dist/adapters/index.js
+var require_adapters = __commonJS({
+  "../forge/packages/core/dist/adapters/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HttpAdapter = exports.GitAdapter = exports.CompositeAdapter = exports.FilesystemAdapter = exports.ForgeCoreVersionMismatchError = exports.PreUploadValidationError = exports.PublishValidationError = exports.PublishPushError = exports.PublishAuthError = exports.VersionConflictError = exports.AllAdaptersFailedError = exports.AdapterError = exports.UnsupportedTargetError = exports.VersionMismatchError = exports.CircularDependencyError = exports.InvalidMetadataError = exports.ArtifactNotFoundError = exports.ForgeError = void 0;
+    var errors_js_1 = require_errors();
+    Object.defineProperty(exports, "ForgeError", { enumerable: true, get: function() {
+      return errors_js_1.ForgeError;
+    } });
+    Object.defineProperty(exports, "ArtifactNotFoundError", { enumerable: true, get: function() {
+      return errors_js_1.ArtifactNotFoundError;
+    } });
+    Object.defineProperty(exports, "InvalidMetadataError", { enumerable: true, get: function() {
+      return errors_js_1.InvalidMetadataError;
+    } });
+    Object.defineProperty(exports, "CircularDependencyError", { enumerable: true, get: function() {
+      return errors_js_1.CircularDependencyError;
+    } });
+    Object.defineProperty(exports, "VersionMismatchError", { enumerable: true, get: function() {
+      return errors_js_1.VersionMismatchError;
+    } });
+    Object.defineProperty(exports, "UnsupportedTargetError", { enumerable: true, get: function() {
+      return errors_js_1.UnsupportedTargetError;
+    } });
+    Object.defineProperty(exports, "AdapterError", { enumerable: true, get: function() {
+      return errors_js_1.AdapterError;
+    } });
+    Object.defineProperty(exports, "AllAdaptersFailedError", { enumerable: true, get: function() {
+      return errors_js_1.AllAdaptersFailedError;
+    } });
+    Object.defineProperty(exports, "VersionConflictError", { enumerable: true, get: function() {
+      return errors_js_1.VersionConflictError;
+    } });
+    Object.defineProperty(exports, "PublishAuthError", { enumerable: true, get: function() {
+      return errors_js_1.PublishAuthError;
+    } });
+    Object.defineProperty(exports, "PublishPushError", { enumerable: true, get: function() {
+      return errors_js_1.PublishPushError;
+    } });
+    Object.defineProperty(exports, "PublishValidationError", { enumerable: true, get: function() {
+      return errors_js_1.PublishValidationError;
+    } });
+    Object.defineProperty(exports, "PreUploadValidationError", { enumerable: true, get: function() {
+      return errors_js_1.PreUploadValidationError;
+    } });
+    Object.defineProperty(exports, "ForgeCoreVersionMismatchError", { enumerable: true, get: function() {
+      return errors_js_1.ForgeCoreVersionMismatchError;
+    } });
+    var filesystem_adapter_js_1 = require_filesystem_adapter();
+    Object.defineProperty(exports, "FilesystemAdapter", { enumerable: true, get: function() {
+      return filesystem_adapter_js_1.FilesystemAdapter;
+    } });
+    var composite_adapter_js_1 = require_composite_adapter();
+    Object.defineProperty(exports, "CompositeAdapter", { enumerable: true, get: function() {
+      return composite_adapter_js_1.CompositeAdapter;
+    } });
+    var git_adapter_js_1 = require_git_adapter();
+    Object.defineProperty(exports, "GitAdapter", { enumerable: true, get: function() {
+      return git_adapter_js_1.GitAdapter;
+    } });
+    var http_adapter_js_1 = require_http_adapter();
+    Object.defineProperty(exports, "HttpAdapter", { enumerable: true, get: function() {
+      return http_adapter_js_1.HttpAdapter;
+    } });
+  }
+});
+
+// ../forge/packages/core/dist/resolver/index.js
+var require_resolver2 = __commonJS({
+  "../forge/packages/core/dist/resolver/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.mergeWorkspaceConfigs = exports.Resolver = void 0;
+    var resolver_js_1 = require_resolver();
+    Object.defineProperty(exports, "Resolver", { enumerable: true, get: function() {
+      return resolver_js_1.Resolver;
+    } });
+    var merge_workspace_configs_js_1 = require_merge_workspace_configs();
+    Object.defineProperty(exports, "mergeWorkspaceConfigs", { enumerable: true, get: function() {
+      return merge_workspace_configs_js_1.mergeWorkspaceConfigs;
+    } });
+  }
+});
+
+// ../forge/packages/core/dist/workspace/workspace-migration.js
+var require_workspace_migration = __commonJS({
+  "../forge/packages/core/dist/workspace/workspace-migration.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.runStartupMigrations = runStartupMigrations;
+    var fs_1 = __require("fs");
+    var path_1 = __importDefault(__require("path"));
+    var global_config_loader_js_1 = require_global_config_loader();
+    var path_utils_js_1 = require_path_utils();
+    var workspace_metadata_store_js_1 = require_workspace_metadata_store();
+    var mcp_settings_writer_js_1 = require_mcp_settings_writer();
+    async function runStartupMigrations(globalConfigPath) {
+      try {
+        await migrateReadGuardHook(globalConfigPath);
+      } catch (err) {
+        process.stderr.write(JSON.stringify({
+          level: "warn",
+          message: "[Forge] Startup migration failed",
+          error: err?.message ?? String(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }) + "\n");
+      }
+    }
+    async function migrateReadGuardHook(globalConfigPath) {
+      const globalConfig = await (0, global_config_loader_js_1.loadGlobalConfig)(globalConfigPath);
+      const mountPath = (0, path_utils_js_1.expandPath)(globalConfig.workspace.mount_path);
+      const hostMountPath = globalConfig.workspace.host_workspaces_path ? globalConfig.workspace.host_workspaces_path : mountPath;
+      const metaStore = new workspace_metadata_store_js_1.WorkspaceMetadataStore(globalConfig.workspace.store_path);
+      const workspaces = await metaStore.list({ status: "active" });
+      for (const ws of workspaces) {
+        const guardScript = path_1.default.join(ws.path, ".claude", "scripts", "guard-source-reads.sh");
+        let missing = false;
+        try {
+          await fs_1.promises.access(guardScript);
+        } catch {
+          missing = true;
+        }
+        if (!missing) {
+          continue;
+        }
+        const hostWorkspacePath = path_1.default.join(hostMountPath, ws.name);
+        try {
+          await (0, mcp_settings_writer_js_1.emitReadGuardHook)(ws.path, hostWorkspacePath);
+          process.stderr.write(JSON.stringify({
+            level: "info",
+            message: "[Forge] Migration: emitted read guard hook",
+            workspace: ws.name,
+            workspaceId: ws.id,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }) + "\n");
+        } catch (err) {
+          process.stderr.write(JSON.stringify({
+            level: "warn",
+            message: "[Forge] Migration: failed to emit read guard hook",
+            workspace: ws.name,
+            workspaceId: ws.id,
+            error: err?.message ?? String(err),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }) + "\n");
+        }
+      }
+    }
+  }
+});
+
+// ../forge/packages/core/dist/workspace/index.js
+var require_workspace = __commonJS({
+  "../forge/packages/core/dist/workspace/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.runStartupMigrations = exports.WRAPPER_PATH = exports.updateClaudeMcpServers = exports.emitMcpRemoteWrapper = exports.WorkspaceLifecycleManager = exports.generateBranchName = exports.slugify = exports.WorkspaceCreateError = exports.WorkspaceCreator = exports.WORKSPACES_FILE = exports.generateWorkspaceId = exports.WorkspaceMetadataStore = exports.WorkspaceManager = void 0;
+    var workspace_manager_js_1 = require_workspace_manager();
+    Object.defineProperty(exports, "WorkspaceManager", { enumerable: true, get: function() {
+      return workspace_manager_js_1.WorkspaceManager;
+    } });
+    var workspace_metadata_store_js_1 = require_workspace_metadata_store();
+    Object.defineProperty(exports, "WorkspaceMetadataStore", { enumerable: true, get: function() {
+      return workspace_metadata_store_js_1.WorkspaceMetadataStore;
+    } });
+    Object.defineProperty(exports, "generateWorkspaceId", { enumerable: true, get: function() {
+      return workspace_metadata_store_js_1.generateWorkspaceId;
+    } });
+    Object.defineProperty(exports, "WORKSPACES_FILE", { enumerable: true, get: function() {
+      return workspace_metadata_store_js_1.WORKSPACES_FILE;
+    } });
+    var workspace_creator_js_1 = require_workspace_creator();
+    Object.defineProperty(exports, "WorkspaceCreator", { enumerable: true, get: function() {
+      return workspace_creator_js_1.WorkspaceCreator;
+    } });
+    Object.defineProperty(exports, "WorkspaceCreateError", { enumerable: true, get: function() {
+      return workspace_creator_js_1.WorkspaceCreateError;
+    } });
+    Object.defineProperty(exports, "slugify", { enumerable: true, get: function() {
+      return workspace_creator_js_1.slugify;
+    } });
+    Object.defineProperty(exports, "generateBranchName", { enumerable: true, get: function() {
+      return workspace_creator_js_1.generateBranchName;
+    } });
+    var workspace_lifecycle_js_1 = require_workspace_lifecycle();
+    Object.defineProperty(exports, "WorkspaceLifecycleManager", { enumerable: true, get: function() {
+      return workspace_lifecycle_js_1.WorkspaceLifecycleManager;
+    } });
+    var mcp_settings_writer_js_1 = require_mcp_settings_writer();
+    Object.defineProperty(exports, "emitMcpRemoteWrapper", { enumerable: true, get: function() {
+      return mcp_settings_writer_js_1.emitMcpRemoteWrapper;
+    } });
+    Object.defineProperty(exports, "updateClaudeMcpServers", { enumerable: true, get: function() {
+      return mcp_settings_writer_js_1.updateClaudeMcpServers;
+    } });
+    Object.defineProperty(exports, "WRAPPER_PATH", { enumerable: true, get: function() {
+      return mcp_settings_writer_js_1.WRAPPER_PATH;
+    } });
+    var workspace_migration_js_1 = require_workspace_migration();
+    Object.defineProperty(exports, "runStartupMigrations", { enumerable: true, get: function() {
+      return workspace_migration_js_1.runStartupMigrations;
+    } });
+  }
+});
+
+// ../forge/packages/core/dist/compiler/index.js
+var require_compiler2 = __commonJS({
+  "../forge/packages/core/dist/compiler/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.removeManagedSection = exports.upsertManagedSection = exports.GlobalClaudeCodeStrategy = exports.CursorStrategy = exports.ClaudeCodeStrategy = exports.Compiler = void 0;
+    var compiler_js_1 = require_compiler();
+    Object.defineProperty(exports, "Compiler", { enumerable: true, get: function() {
+      return compiler_js_1.Compiler;
+    } });
+    var claude_code_strategy_js_1 = require_claude_code_strategy();
+    Object.defineProperty(exports, "ClaudeCodeStrategy", { enumerable: true, get: function() {
+      return claude_code_strategy_js_1.ClaudeCodeStrategy;
+    } });
+    var cursor_strategy_js_1 = require_cursor_strategy();
+    Object.defineProperty(exports, "CursorStrategy", { enumerable: true, get: function() {
+      return cursor_strategy_js_1.CursorStrategy;
+    } });
+    var global_claude_code_strategy_js_1 = require_global_claude_code_strategy();
+    Object.defineProperty(exports, "GlobalClaudeCodeStrategy", { enumerable: true, get: function() {
+      return global_claude_code_strategy_js_1.GlobalClaudeCodeStrategy;
+    } });
+    var claude_md_writer_js_1 = require_claude_md_writer();
+    Object.defineProperty(exports, "upsertManagedSection", { enumerable: true, get: function() {
+      return claude_md_writer_js_1.upsertManagedSection;
+    } });
+    Object.defineProperty(exports, "removeManagedSection", { enumerable: true, get: function() {
+      return claude_md_writer_js_1.removeManagedSection;
+    } });
+  }
+});
+
+// ../forge/packages/core/dist/config/index.js
+var require_config = __commonJS({
+  "../forge/packages/core/dist/config/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.expandPaths = exports.expandPath = exports.GLOBAL_CONFIG_PATH = exports.GLOBAL_CONFIG_DIR = exports.DEFAULT_GLOBAL_REGISTRY = exports.DEFAULT_LOCAL_REGISTRY = exports.selectSharedRepoRegistry = exports.ensureDefaultRegistries = exports.removeGlobalRegistry = exports.addGlobalRegistry = exports.saveGlobalConfig = exports.loadGlobalConfig = void 0;
+    var global_config_loader_js_1 = require_global_config_loader();
+    Object.defineProperty(exports, "loadGlobalConfig", { enumerable: true, get: function() {
+      return global_config_loader_js_1.loadGlobalConfig;
+    } });
+    Object.defineProperty(exports, "saveGlobalConfig", { enumerable: true, get: function() {
+      return global_config_loader_js_1.saveGlobalConfig;
+    } });
+    Object.defineProperty(exports, "addGlobalRegistry", { enumerable: true, get: function() {
+      return global_config_loader_js_1.addGlobalRegistry;
+    } });
+    Object.defineProperty(exports, "removeGlobalRegistry", { enumerable: true, get: function() {
+      return global_config_loader_js_1.removeGlobalRegistry;
+    } });
+    Object.defineProperty(exports, "ensureDefaultRegistries", { enumerable: true, get: function() {
+      return global_config_loader_js_1.ensureDefaultRegistries;
+    } });
+    Object.defineProperty(exports, "selectSharedRepoRegistry", { enumerable: true, get: function() {
+      return global_config_loader_js_1.selectSharedRepoRegistry;
+    } });
+    Object.defineProperty(exports, "DEFAULT_LOCAL_REGISTRY", { enumerable: true, get: function() {
+      return global_config_loader_js_1.DEFAULT_LOCAL_REGISTRY;
+    } });
+    Object.defineProperty(exports, "DEFAULT_GLOBAL_REGISTRY", { enumerable: true, get: function() {
+      return global_config_loader_js_1.DEFAULT_GLOBAL_REGISTRY;
+    } });
+    Object.defineProperty(exports, "GLOBAL_CONFIG_DIR", { enumerable: true, get: function() {
+      return global_config_loader_js_1.GLOBAL_CONFIG_DIR;
+    } });
+    Object.defineProperty(exports, "GLOBAL_CONFIG_PATH", { enumerable: true, get: function() {
+      return global_config_loader_js_1.GLOBAL_CONFIG_PATH;
+    } });
+    var path_utils_js_1 = require_path_utils();
+    Object.defineProperty(exports, "expandPath", { enumerable: true, get: function() {
+      return path_utils_js_1.expandPath;
+    } });
+    Object.defineProperty(exports, "expandPaths", { enumerable: true, get: function() {
+      return path_utils_js_1.expandPaths;
+    } });
+  }
+});
+
+// ../forge/packages/core/dist/repo/clone-layout.js
+var require_clone_layout = __commonJS({
+  "../forge/packages/core/dist/repo/clone-layout.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.horusDataPath = horusDataPath;
+    exports.horusReposRoot = horusReposRoot;
+    exports.repoClonePath = repoClonePath;
+    exports.repoClonePathFromCoordinate = repoClonePathFromCoordinate;
+    exports.repoWorktreesDir = repoWorktreesDir;
+    exports.worktreePath = worktreePath;
+    exports.ensureHorusIgnored = ensureHorusIgnored;
+    var node_os_1 = __require("os");
+    var node_path_1 = __require("path");
+    var node_fs_1 = __require("fs");
+    var url_utils_js_1 = require_url_utils();
+    function horusDataPath() {
+      return process.env.HORUS_DATA_PATH || (0, node_path_1.join)((0, node_os_1.homedir)(), "Horus", "data");
+    }
+    function horusReposRoot(dataPath = horusDataPath()) {
+      return (0, node_path_1.join)(dataPath, "repos");
+    }
+    function repoClonePath(url, dataPath = horusDataPath()) {
+      const { host, org, name } = (0, url_utils_js_1.deriveRepoCoordinate)(url);
+      return (0, node_path_1.join)(horusReposRoot(dataPath), host, org, name);
+    }
+    function repoClonePathFromCoordinate(coord, dataPath = horusDataPath()) {
+      return (0, node_path_1.join)(horusReposRoot(dataPath), coord.host, coord.org, coord.name);
+    }
+    function repoWorktreesDir(clonePath) {
+      return (0, node_path_1.join)(clonePath, ".horus", "worktrees");
+    }
+    function worktreePath(clonePath, sessionId) {
+      return (0, node_path_1.join)(repoWorktreesDir(clonePath), sessionId);
+    }
+    var HORUS_EXCLUDE_LINE = "/.horus/";
+    async function ensureHorusIgnored(clonePath) {
+      const excludePath = (0, node_path_1.join)(clonePath, ".git", "info", "exclude");
+      let existing = "";
+      try {
+        existing = await node_fs_1.promises.readFile(excludePath, "utf8");
+      } catch (err) {
+        if (err.code !== "ENOENT")
+          throw err;
+        await node_fs_1.promises.mkdir((0, node_path_1.join)(clonePath, ".git", "info"), { recursive: true });
+      }
+      const lines = existing.split("\n").map((l) => l.trim());
+      if (lines.includes(HORUS_EXCLUDE_LINE) || lines.includes(".horus/")) {
+        return;
+      }
+      const prefix = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+      await node_fs_1.promises.appendFile(excludePath, `${prefix}# Horus-managed session worktrees (do not commit)
+${HORUS_EXCLUDE_LINE}
+`);
+    }
+  }
+});
+
+// ../forge/packages/core/dist/repo/local-repo-state-store.js
+var require_local_repo_state_store = __commonJS({
+  "../forge/packages/core/dist/repo/local-repo-state-store.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LocalRepoStateStoreManager = void 0;
+    exports.repoStatePath = repoStatePath;
+    var node_fs_1 = __require("fs");
+    var node_path_1 = __importDefault(__require("path"));
+    var local_repo_state_js_1 = require_local_repo_state();
+    var clone_layout_js_1 = require_clone_layout();
+    function repoStatePath(dataPath = (0, clone_layout_js_1.horusDataPath)()) {
+      return node_path_1.default.join(dataPath, "config", "repo-state.json");
+    }
+    var LocalRepoStateStoreManager = class {
+      storePath;
+      constructor(storePath = repoStatePath()) {
+        this.storePath = storePath;
+      }
+      async load() {
+        try {
+          const raw = await node_fs_1.promises.readFile(this.storePath, "utf8");
+          return local_repo_state_js_1.LocalRepoStateStoreSchema.parse(JSON.parse(raw));
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            return { ...local_repo_state_js_1.EMPTY_LOCAL_REPO_STATE, repos: [] };
+          }
+          throw err;
+        }
+      }
+      async save(store) {
+        await node_fs_1.promises.mkdir(node_path_1.default.dirname(this.storePath), { recursive: true });
+        await node_fs_1.promises.writeFile(this.storePath, JSON.stringify(store, null, 2), "utf8");
+      }
+      async get(clonePath) {
+        const store = await this.load();
+        return store.repos.find((r) => r.clonePath === clonePath) ?? null;
+      }
+      /** Insert or replace the entry for this clonePath (dedup-safe). */
+      async upsert(entry) {
+        const store = await this.load();
+        const idx = store.repos.findIndex((r) => r.clonePath === entry.clonePath);
+        if (idx >= 0)
+          store.repos[idx] = entry;
+        else
+          store.repos.push(entry);
+        await this.save(store);
+      }
+      /** Patch fields on an existing entry, creating it if absent. */
+      async patch(seed, patch) {
+        const store = await this.load();
+        let entry = store.repos.find((r) => r.clonePath === seed.clonePath);
+        if (!entry) {
+          entry = { ...seed, lastFetchedAt: null, lastUsedAt: null, worktrees: [] };
+          store.repos.push(entry);
+        }
+        Object.assign(entry, patch);
+        await this.save(store);
+        return entry;
+      }
+      /** Add a worktree record, deduped by sessionId. */
+      async addWorktree(clonePath, wt) {
+        const store = await this.load();
+        const entry = store.repos.find((r) => r.clonePath === clonePath);
+        if (!entry)
+          throw new Error(`LocalRepoState: no entry for ${clonePath}`);
+        if (!entry.worktrees.some((w) => w.sessionId === wt.sessionId)) {
+          entry.worktrees.push(wt);
+        }
+        await this.save(store);
+      }
+    };
+    exports.LocalRepoStateStoreManager = LocalRepoStateStoreManager;
+  }
+});
+
+// ../forge/packages/core/dist/repo/clone-semantics.js
+var require_clone_semantics = __commonJS({
+  "../forge/packages/core/dist/repo/clone-semantics.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DEFAULT_CLONE_TTL_MS = void 0;
+    exports.cloneTtlMs = cloneTtlMs;
+    exports.isCloneStale = isCloneStale;
+    exports.ensureClone = ensureClone;
+    exports.refreshIfStale = refreshIfStale;
+    exports.createSessionWorktree = createSessionWorktree;
+    var node_fs_1 = __require("fs");
+    var node_path_1 = __require("path");
+    var node_child_process_1 = __require("child_process");
+    var node_util_1 = __require("util");
+    var clone_layout_js_1 = require_clone_layout();
+    var url_utils_js_1 = require_url_utils();
+    var local_repo_state_store_js_1 = require_local_repo_state_store();
+    var execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+    exports.DEFAULT_CLONE_TTL_MS = 60 * 60 * 1e3;
+    function cloneTtlMs(override) {
+      if (typeof override === "number")
+        return override;
+      const env = process.env.HORUS_CLONE_TTL_MS;
+      if (env && Number.isFinite(Number(env)))
+        return Number(env);
+      return exports.DEFAULT_CLONE_TTL_MS;
+    }
+    function isCloneStale(lastFetchedAt, ttlMs, now) {
+      if (lastFetchedAt === null)
+        return true;
+      return now.getTime() - new Date(lastFetchedAt).getTime() > ttlMs;
+    }
+    async function isGitRepo(dir) {
+      try {
+        await execFileAsync("git", ["rev-parse", "--git-dir"], { cwd: dir });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    async function ensureClone(url, opts = {}) {
+      const dataPath = opts.dataPath ?? (0, clone_layout_js_1.horusDataPath)();
+      const clonePath = (0, clone_layout_js_1.repoClonePath)(url, dataPath);
+      const coord = (0, url_utils_js_1.deriveRepoCoordinate)(url);
+      const store = new local_repo_state_store_js_1.LocalRepoStateStoreManager((0, local_repo_state_store_js_1.repoStatePath)(dataPath));
+      if (await isGitRepo(clonePath)) {
+        await store.patch({ ...coord, clonePath }, {});
+        await (0, clone_layout_js_1.ensureHorusIgnored)(clonePath);
+        return clonePath;
+      }
+      await node_fs_1.promises.rm(clonePath, { recursive: true, force: true }).catch(() => {
+      });
+      const tmpPath = `${clonePath}.tmp-${process.pid}-${Date.now()}`;
+      await node_fs_1.promises.mkdir((0, node_path_1.dirname)(clonePath), { recursive: true });
+      try {
+        await execFileAsync("git", ["clone", url, tmpPath], {
+          timeout: opts.gitTimeoutMs ?? 12e4
+        });
+        await node_fs_1.promises.rename(tmpPath, clonePath);
+      } catch (err) {
+        await node_fs_1.promises.rm(tmpPath, { recursive: true, force: true }).catch(() => {
+        });
+        throw err;
+      }
+      await (0, clone_layout_js_1.ensureHorusIgnored)(clonePath);
+      await store.patch({ ...coord, clonePath }, {});
+      return clonePath;
+    }
+    async function refreshIfStale(url, baseBranch, opts = {}) {
+      const dataPath = opts.dataPath ?? (0, clone_layout_js_1.horusDataPath)();
+      const now = (opts.now ?? (() => /* @__PURE__ */ new Date()))();
+      const ttl = cloneTtlMs(opts.ttlMs);
+      const clonePath = (0, clone_layout_js_1.repoClonePath)(url, dataPath);
+      const coord = (0, url_utils_js_1.deriveRepoCoordinate)(url);
+      const store = new local_repo_state_store_js_1.LocalRepoStateStoreManager((0, local_repo_state_store_js_1.repoStatePath)(dataPath));
+      const entry = await store.get(clonePath);
+      if (!isCloneStale(entry?.lastFetchedAt ?? null, ttl, now))
+        return false;
+      await execFileAsync("git", ["fetch", "origin", baseBranch], {
+        cwd: clonePath,
+        timeout: opts.gitTimeoutMs ?? 12e4
+      });
+      await store.patch({ ...coord, clonePath }, { lastFetchedAt: now.toISOString() });
+      return true;
+    }
+    async function createSessionWorktree(url, sessionId, baseBranch, branch, opts = {}) {
+      const dataPath = opts.dataPath ?? (0, clone_layout_js_1.horusDataPath)();
+      const now = (opts.now ?? (() => /* @__PURE__ */ new Date()))();
+      const clonePath = await ensureClone(url, opts);
+      await refreshIfStale(url, baseBranch, opts);
+      const wtPath = (0, clone_layout_js_1.worktreePath)(clonePath, sessionId);
+      await execFileAsync("git", ["worktree", "add", "-b", branch, wtPath, `origin/${baseBranch}`], { cwd: clonePath, timeout: opts.gitTimeoutMs ?? 12e4 });
+      const coord = (0, url_utils_js_1.deriveRepoCoordinate)(url);
+      const store = new local_repo_state_store_js_1.LocalRepoStateStoreManager((0, local_repo_state_store_js_1.repoStatePath)(dataPath));
+      await store.patch({ ...coord, clonePath }, { lastUsedAt: now.toISOString() });
+      await store.addWorktree(clonePath, {
+        sessionId,
+        path: wtPath,
+        branch,
+        createdAt: now.toISOString()
+      });
+      return wtPath;
+    }
+  }
+});
+
+// ../forge/packages/core/dist/session/agent-spawn.js
+var require_agent_spawn = __commonJS({
+  "../forge/packages/core/dist/session/agent-spawn.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.buildClaudeArgs = buildClaudeArgs;
+    exports.spawnAgentSession = spawnAgentSession;
+    var child_process_1 = __require("child_process");
+    var util_1 = __require("util");
+    var errors_js_1 = require_errors();
+    var execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+    var MAX_BUFFER = 64 * 1024 * 1024;
+    function resolveClaudeBin(opts) {
+      return opts.claudeBin ?? process.env.CLAUDE_BIN ?? "claude";
+    }
+    function buildClaudeArgs(opts) {
+      const args = ["-p", opts.prompt, "--output-format", "json"];
+      if (opts.resume)
+        args.push("--resume", opts.resume);
+      args.push("--permission-mode", opts.permissionMode ?? "acceptEdits");
+      if (opts.allowedTools && opts.allowedTools.length > 0) {
+        args.push("--allowedTools", opts.allowedTools.join(","));
+      }
+      if (typeof opts.maxTurns === "number") {
+        args.push("--max-turns", String(opts.maxTurns));
+      }
+      return args;
+    }
+    async function spawnAgentSession(opts) {
+      const bin = resolveClaudeBin(opts);
+      const args = buildClaudeArgs(opts);
+      let stdout;
+      try {
+        const res = await execFileAsync(bin, args, {
+          cwd: opts.cwd,
+          timeout: opts.timeoutMs ?? 0,
+          maxBuffer: MAX_BUFFER,
+          encoding: "utf8"
+          // guarantee string stdout (and string err.stdout on the salvage path)
+        });
+        stdout = res.stdout;
+      } catch (err) {
+        if (err?.code === "ENOENT") {
+          throw new errors_js_1.ForgeError("AGENT_BIN_NOT_FOUND", `Claude Code binary "${bin}" was not found on PATH.`, `Install Claude Code or set CLAUDE_BIN to its absolute path. The edit-flow spawn requires a non-bare claude executable.`);
+        }
+        const salvaged = typeof err?.stdout === "string" ? err.stdout : "";
+        if (salvaged.trim()) {
+          stdout = salvaged;
+        } else {
+          throw new errors_js_1.ForgeError("AGENT_SPAWN_FAILED", `Headless claude run failed (cwd=${opts.cwd}): ${err?.message ?? "unknown error"}`, `Verify the worktree is valid and the claude session can authenticate (non-bare inherits the logged-in credential).`);
+        }
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(stdout);
+      } catch {
+        throw new errors_js_1.ForgeError("AGENT_OUTPUT_UNPARSEABLE", `Could not parse JSON from "claude --output-format json" (cwd=${opts.cwd}).`, `First 400 chars of output: ${stdout.slice(0, 400)}`);
+      }
+      const claudeSessionId = parsed["session_id"] ?? parsed["sessionId"];
+      if (!claudeSessionId) {
+        throw new errors_js_1.ForgeError("AGENT_OUTPUT_MISSING_SESSION_ID", `"claude --output-format json" did not return a session_id (cwd=${opts.cwd}).`, `session_id is required for resume + provenance. Confirm the Claude Code version supports --output-format json.`);
+      }
+      return {
+        claudeSessionId,
+        result: typeof parsed["result"] === "string" ? parsed["result"] : "",
+        isError: parsed["is_error"] === true,
+        costUsd: typeof parsed["total_cost_usd"] === "number" ? parsed["total_cost_usd"] : void 0,
+        numTurns: typeof parsed["num_turns"] === "number" ? parsed["num_turns"] : void 0,
+        raw: parsed
+      };
+    }
+  }
+});
+
+// ../forge/packages/core/dist/session/gc.js
+var require_gc = __commonJS({
+  "../forge/packages/core/dist/session/gc.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isCleanTree = isCleanTree;
+    exports.classifyWorktree = classifyWorktree;
+    exports.getWorktreeTreeState = getWorktreeTreeState;
+    exports.worktreeGc = worktreeGc;
+    exports.cloneGc = cloneGc;
+    var node_fs_1 = __require("fs");
+    var node_child_process_1 = __require("child_process");
+    var node_util_1 = __require("util");
+    var local_repo_state_store_js_1 = require_local_repo_state_store();
+    var execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+    var ACTIVE_STATUSES = /* @__PURE__ */ new Set([
+      "in_progress",
+      "in-progress",
+      "in_review",
+      "in-review",
+      "open",
+      "blocked"
+    ]);
+    function isCleanTree(t) {
+      return t.determined && !t.uncommitted && !t.unpushed && !t.stash;
+    }
+    function classifyWorktree(input2) {
+      const reasons = [];
+      const active = input2.status !== null && ACTIVE_STATUSES.has(input2.status);
+      if (active)
+        reasons.push(`work item status '${input2.status}' is active`);
+      if (input2.status === null)
+        reasons.push("work item status unknown (Anvil) \u2014 treated as active/unsafe");
+      const clean = isCleanTree(input2.tree);
+      if (!input2.tree.determined)
+        reasons.push("tree state could not be determined \u2014 treated as dirty/unsafe");
+      else {
+        if (input2.tree.uncommitted)
+          reasons.push("uncommitted changes");
+        if (input2.tree.unpushed)
+          reasons.push("unpushed commits");
+        if (input2.tree.stash)
+          reasons.push("stash entries present");
+      }
+      const eligible = !active && input2.status !== null && clean;
+      if (eligible)
+        reasons.push(`inactive + clean (age ${Math.round(input2.ageMs / 864e5)}d, informational only)`);
+      return { eligible, reasons };
+    }
+    async function getWorktreeTreeState(worktreePath) {
+      try {
+        const { stdout: porcelain } = await execFileAsync("git", ["status", "--porcelain"], {
+          cwd: worktreePath,
+          timeout: 15e3
+        });
+        const { stdout: stashList } = await execFileAsync("git", ["stash", "list"], {
+          cwd: worktreePath,
+          timeout: 1e4
+        });
+        let unpushed = true;
+        try {
+          const { stdout: up } = await execFileAsync("git", ["rev-list", "--count", "@{upstream}..HEAD"], { cwd: worktreePath, timeout: 1e4 });
+          unpushed = parseInt(up.trim(), 10) > 0;
+        } catch {
+          unpushed = true;
+        }
+        return {
+          uncommitted: porcelain.trim().length > 0,
+          unpushed,
+          stash: stashList.trim().length > 0,
+          determined: true
+        };
+      } catch {
+        return { uncommitted: true, unpushed: true, stash: true, determined: false };
+      }
+    }
+    async function worktreeGc(opts) {
+      const dataPath = opts.dataPath;
+      const now = (opts.now ?? (() => /* @__PURE__ */ new Date()))();
+      const store = new local_repo_state_store_js_1.LocalRepoStateStoreManager((0, local_repo_state_store_js_1.repoStatePath)(dataPath));
+      const state = await store.load();
+      const reclaimed = [];
+      const retained = [];
+      for (const entry of state.repos) {
+        for (const wt of entry.worktrees) {
+          const status = await opts.resolveStatus(wt, entry);
+          const tree = await getWorktreeTreeState(wt.path);
+          const ageMs = now.getTime() - new Date(wt.createdAt).getTime();
+          const { eligible, reasons } = classifyWorktree({ status, tree, ageMs });
+          const cand = {
+            clonePath: entry.clonePath,
+            sessionId: wt.sessionId,
+            worktreePath: wt.path,
+            branch: wt.branch,
+            eligible,
+            reasons
+          };
+          if (eligible)
+            reclaimed.push(cand);
+          else
+            retained.push(cand);
+        }
+      }
+      if (opts.apply === true) {
+        for (const cand of reclaimed) {
+          await execFileAsync("git", ["worktree", "remove", "--force", cand.worktreePath], {
+            cwd: cand.clonePath,
+            timeout: 15e3
+          }).catch(() => {
+          });
+          await execFileAsync("git", ["worktree", "prune"], {
+            cwd: cand.clonePath,
+            timeout: 1e4
+          }).catch(() => {
+          });
+          await node_fs_1.promises.rm(cand.worktreePath, { recursive: true, force: true }).catch(() => {
+          });
+          const entry = state.repos.find((r) => r.clonePath === cand.clonePath);
+          entry.worktrees = entry.worktrees.filter((w) => w.sessionId !== cand.sessionId);
+        }
+        await store.save(state);
+      }
+      return { applied: opts.apply === true, reclaimed, retained };
+    }
+    async function cloneGc(opts) {
+      const now = (opts.now ?? (() => /* @__PURE__ */ new Date()))();
+      const store = new local_repo_state_store_js_1.LocalRepoStateStoreManager((0, local_repo_state_store_js_1.repoStatePath)(opts.dataPath));
+      const state = await store.load();
+      const reclaimed = [];
+      const retained = [];
+      for (const entry of state.repos) {
+        const reasons = [];
+        let eligible = true;
+        if (entry.worktrees.length > 0) {
+          eligible = false;
+          reasons.push(`${entry.worktrees.length} live worktree(s) \u2014 never reclaim`);
+        } else if (entry.lastUsedAt === null) {
+          eligible = false;
+          reasons.push("never used \u2014 no LRU signal, retained");
+        } else {
+          const idle = now.getTime() - new Date(entry.lastUsedAt).getTime();
+          if (idle <= opts.maxIdleMs) {
+            eligible = false;
+            reasons.push(`idle ${Math.round(idle / 864e5)}d \u2264 threshold \u2014 retained`);
+          } else {
+            reasons.push(`idle ${Math.round(idle / 864e5)}d > threshold, no live worktrees`);
+          }
+        }
+        const cand = {
+          clonePath: entry.clonePath,
+          liveWorktrees: entry.worktrees.length,
+          lastUsedAt: entry.lastUsedAt,
+          eligible,
+          reasons
+        };
+        if (eligible)
+          reclaimed.push(cand);
+        else
+          retained.push(cand);
+      }
+      if (opts.apply === true) {
+        for (const cand of reclaimed) {
+          await node_fs_1.promises.rm(cand.clonePath, { recursive: true, force: true }).catch(() => {
+          });
+        }
+        state.repos = state.repos.filter((r) => !reclaimed.some((c) => c.clonePath === r.clonePath));
+        await store.save(state);
+      }
+      return { applied: opts.apply === true, reclaimed, retained };
+    }
+  }
+});
+
+// ../forge/packages/core/dist/index.js
+var require_dist = __commonJS({
+  "../forge/packages/core/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__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 = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.cloneGc = exports.worktreeGc = exports.getWorktreeTreeState = exports.isCleanTree = exports.classifyWorktree = exports.sessionCleanup = exports.sessionList = exports.SessionStoreManager = exports.ForgeSearchClient = exports.RepoAmbiguousError = exports.RepoExistsError = exports.RepoNotFoundError = exports.RepoRegistryClient = exports.buildClaudeArgs = exports.spawnAgentSession = exports.repoDevelop = exports.repoStatePath = exports.LocalRepoStateStoreManager = exports.createSessionWorktree = exports.refreshIfStale = exports.ensureClone = exports.DEFAULT_CLONE_TTL_MS = exports.cloneTtlMs = exports.isCloneStale = exports.ensureHorusIgnored = exports.worktreePath = exports.repoWorktreesDir = exports.repoClonePathFromCoordinate = exports.repoClonePath = exports.horusReposRoot = exports.horusDataPath = exports.deriveRepoCoordinate = exports.normalizeHost = exports.normalizeGitUrl = exports.RepoIndexQuery = exports.loadRepoIndex = exports.saveRepoIndex = exports.scan = exports.Registry = exports.ForgeCore = void 0;
+    var core_js_1 = require_core();
+    Object.defineProperty(exports, "ForgeCore", { enumerable: true, get: function() {
+      return core_js_1.ForgeCore;
+    } });
+    var registry_js_1 = require_registry();
+    Object.defineProperty(exports, "Registry", { enumerable: true, get: function() {
+      return registry_js_1.Registry;
+    } });
+    __exportStar(require_models(), exports);
+    __exportStar(require_adapters(), exports);
+    __exportStar(require_resolver2(), exports);
+    __exportStar(require_workspace(), exports);
+    __exportStar(require_compiler2(), exports);
+    __exportStar(require_config(), exports);
+    var repo_scanner_js_1 = require_repo_scanner();
+    Object.defineProperty(exports, "scan", { enumerable: true, get: function() {
+      return repo_scanner_js_1.scan;
+    } });
+    var repo_index_store_js_1 = require_repo_index_store();
+    Object.defineProperty(exports, "saveRepoIndex", { enumerable: true, get: function() {
+      return repo_index_store_js_1.saveRepoIndex;
+    } });
+    Object.defineProperty(exports, "loadRepoIndex", { enumerable: true, get: function() {
+      return repo_index_store_js_1.loadRepoIndex;
+    } });
+    var repo_index_query_js_1 = require_repo_index_query();
+    Object.defineProperty(exports, "RepoIndexQuery", { enumerable: true, get: function() {
+      return repo_index_query_js_1.RepoIndexQuery;
+    } });
+    var url_utils_js_1 = require_url_utils();
+    Object.defineProperty(exports, "normalizeGitUrl", { enumerable: true, get: function() {
+      return url_utils_js_1.normalizeGitUrl;
+    } });
+    Object.defineProperty(exports, "normalizeHost", { enumerable: true, get: function() {
+      return url_utils_js_1.normalizeHost;
+    } });
+    Object.defineProperty(exports, "deriveRepoCoordinate", { enumerable: true, get: function() {
+      return url_utils_js_1.deriveRepoCoordinate;
+    } });
+    var clone_layout_js_1 = require_clone_layout();
+    Object.defineProperty(exports, "horusDataPath", { enumerable: true, get: function() {
+      return clone_layout_js_1.horusDataPath;
+    } });
+    Object.defineProperty(exports, "horusReposRoot", { enumerable: true, get: function() {
+      return clone_layout_js_1.horusReposRoot;
+    } });
+    Object.defineProperty(exports, "repoClonePath", { enumerable: true, get: function() {
+      return clone_layout_js_1.repoClonePath;
+    } });
+    Object.defineProperty(exports, "repoClonePathFromCoordinate", { enumerable: true, get: function() {
+      return clone_layout_js_1.repoClonePathFromCoordinate;
+    } });
+    Object.defineProperty(exports, "repoWorktreesDir", { enumerable: true, get: function() {
+      return clone_layout_js_1.repoWorktreesDir;
+    } });
+    Object.defineProperty(exports, "worktreePath", { enumerable: true, get: function() {
+      return clone_layout_js_1.worktreePath;
+    } });
+    Object.defineProperty(exports, "ensureHorusIgnored", { enumerable: true, get: function() {
+      return clone_layout_js_1.ensureHorusIgnored;
+    } });
+    var clone_semantics_js_1 = require_clone_semantics();
+    Object.defineProperty(exports, "isCloneStale", { enumerable: true, get: function() {
+      return clone_semantics_js_1.isCloneStale;
+    } });
+    Object.defineProperty(exports, "cloneTtlMs", { enumerable: true, get: function() {
+      return clone_semantics_js_1.cloneTtlMs;
+    } });
+    Object.defineProperty(exports, "DEFAULT_CLONE_TTL_MS", { enumerable: true, get: function() {
+      return clone_semantics_js_1.DEFAULT_CLONE_TTL_MS;
+    } });
+    Object.defineProperty(exports, "ensureClone", { enumerable: true, get: function() {
+      return clone_semantics_js_1.ensureClone;
+    } });
+    Object.defineProperty(exports, "refreshIfStale", { enumerable: true, get: function() {
+      return clone_semantics_js_1.refreshIfStale;
+    } });
+    Object.defineProperty(exports, "createSessionWorktree", { enumerable: true, get: function() {
+      return clone_semantics_js_1.createSessionWorktree;
+    } });
+    var local_repo_state_store_js_1 = require_local_repo_state_store();
+    Object.defineProperty(exports, "LocalRepoStateStoreManager", { enumerable: true, get: function() {
+      return local_repo_state_store_js_1.LocalRepoStateStoreManager;
+    } });
+    Object.defineProperty(exports, "repoStatePath", { enumerable: true, get: function() {
+      return local_repo_state_store_js_1.repoStatePath;
+    } });
+    var repo_develop_js_1 = require_repo_develop();
+    Object.defineProperty(exports, "repoDevelop", { enumerable: true, get: function() {
+      return repo_develop_js_1.repoDevelop;
+    } });
+    var agent_spawn_js_1 = require_agent_spawn();
+    Object.defineProperty(exports, "spawnAgentSession", { enumerable: true, get: function() {
+      return agent_spawn_js_1.spawnAgentSession;
+    } });
+    Object.defineProperty(exports, "buildClaudeArgs", { enumerable: true, get: function() {
+      return agent_spawn_js_1.buildClaudeArgs;
+    } });
+    var repo_registry_client_js_1 = require_repo_registry_client();
+    Object.defineProperty(exports, "RepoRegistryClient", { enumerable: true, get: function() {
+      return repo_registry_client_js_1.RepoRegistryClient;
+    } });
+    var repo_errors_js_1 = require_repo_errors();
+    Object.defineProperty(exports, "RepoNotFoundError", { enumerable: true, get: function() {
+      return repo_errors_js_1.RepoNotFoundError;
+    } });
+    Object.defineProperty(exports, "RepoExistsError", { enumerable: true, get: function() {
+      return repo_errors_js_1.RepoExistsError;
+    } });
+    Object.defineProperty(exports, "RepoAmbiguousError", { enumerable: true, get: function() {
+      return repo_errors_js_1.RepoAmbiguousError;
+    } });
+    var forge_search_client_js_1 = require_forge_search_client();
+    Object.defineProperty(exports, "ForgeSearchClient", { enumerable: true, get: function() {
+      return forge_search_client_js_1.ForgeSearchClient;
+    } });
+    var session_store_js_1 = require_session_store();
+    Object.defineProperty(exports, "SessionStoreManager", { enumerable: true, get: function() {
+      return session_store_js_1.SessionStoreManager;
+    } });
+    var session_list_js_1 = require_session_list();
+    Object.defineProperty(exports, "sessionList", { enumerable: true, get: function() {
+      return session_list_js_1.sessionList;
+    } });
+    var session_cleanup_js_1 = require_session_cleanup();
+    Object.defineProperty(exports, "sessionCleanup", { enumerable: true, get: function() {
+      return session_cleanup_js_1.sessionCleanup;
+    } });
+    var gc_js_1 = require_gc();
+    Object.defineProperty(exports, "classifyWorktree", { enumerable: true, get: function() {
+      return gc_js_1.classifyWorktree;
+    } });
+    Object.defineProperty(exports, "isCleanTree", { enumerable: true, get: function() {
+      return gc_js_1.isCleanTree;
+    } });
+    Object.defineProperty(exports, "getWorktreeTreeState", { enumerable: true, get: function() {
+      return gc_js_1.getWorktreeTreeState;
+    } });
+    Object.defineProperty(exports, "worktreeGc", { enumerable: true, get: function() {
+      return gc_js_1.worktreeGc;
+    } });
+    Object.defineProperty(exports, "cloneGc", { enumerable: true, get: function() {
+      return gc_js_1.cloneGc;
+    } });
+  }
+});
 
 // src/index.ts
 import { Command as Command16 } from "commander";
@@ -4177,13 +5328,13 @@ var guideCommand = new Command13("guide").description("Print a bundled Horus gui
 import { Command as Command14 } from "commander";
 import chalk14 from "chalk";
 import ora9 from "ora";
-import { RepoRegistryClient } from "@forge/core";
+var import_core2 = __toESM(require_dist(), 1);
 
 // src/lib/repo-migrate.ts
+var import_core = __toESM(require_dist(), 1);
 import { promises as fs } from "fs";
 import os from "os";
 import path from "path";
-import { RepoExistsError } from "@forge/core";
 function inferOrg(remoteUrl) {
   const sshMatch = remoteUrl.match(/git@[^:]+:([^/]+)\//);
   if (sshMatch) return sshMatch[1];
@@ -4235,7 +5386,7 @@ async function migrateRepos(opts) {
       await opts.client.register(input2);
       result.migrated.push(`${org}/${entry.name}`);
     } catch (err) {
-      if (err instanceof RepoExistsError) {
+      if (err instanceof import_core.RepoExistsError) {
         result.skipped.push({ repo: `${org}/${entry.name}`, reason: "already registered" });
       } else {
         const msg = err.message ?? String(err);
@@ -4329,7 +5480,7 @@ repoCommand.command("migrate").description("Import existing repos.json entries i
   }
   const config = loadConfig();
   const registryUrl = opts.registry ?? config.enterprise_registry_url ?? "http://localhost:8744";
-  const client = new RepoRegistryClient({ baseUrl: registryUrl });
+  const client = new import_core2.RepoRegistryClient({ baseUrl: registryUrl });
   if (opts.dryRun) {
     console.log(chalk14.yellow("  Dry-run mode \u2014 no changes will be written to the registry."));
     console.log("");