@alan-ai-hq/agent-manager 0.1.111 → 0.1.113

package/dist/index.cjs

@@ -15243,13 +15243,13 @@ Usage:
   alan-agent <command> [options]
 
 Commands:
-  install     Login/setup, install the daemon service, MCP, and supported hooks
+  install     Login/setup and install the daemon service (MCP + session sync are opt-in)
   setup       Register this computer with a setup token from Alan
   login       Register this computer through browser authorization
   daemon      Start the durable runtime daemon
   service     Install, uninstall, or inspect the per-user daemon service
-  integrations Reconcile, inspect, or uninstall Alan CLI integrations
-  hook        Internal: durably spool a native CLI hook event (fail-open)
+  integrations Reconcile, inspect, or uninstall Alan MCP and session sync
+  hook        Internal: durably spool a native CLI session-sync event (fail-open)
   stop        Stop the local daemon (or active runs only via the local API /stop)
   recover     Redial and safely restart a stuck local daemon connection
   status      Show local runtime configuration without secrets
@@ -15263,6 +15263,7 @@ Commands:
 Common flows:
   alan-agent install
   alan-agent install --setup-token <token>
+  alan-agent install --with-integrations
   alan-agent login
   alan-agent login --cancel
   alan-agent setup --setup-token <token>
@@ -15546,7 +15547,7 @@ function describeError(error61) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.111";
+var AGENT_VERSION = "0.1.113";
 
 // src/daemon-workspace.ts
 var import_node_child_process3 = require("child_process");
@@ -15790,13 +15791,13 @@ function resolveRuntimeCwd(payload) {
 
 // src/daemon-local-control.ts
 var import_node_crypto5 = require("crypto");
-var import_node_fs10 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs9 = require("fs");
+var import_node_path10 = require("path");
 
 // src/daemon-runner-status.ts
-var import_node_fs9 = require("fs");
+var import_node_fs8 = require("fs");
 var import_node_os5 = require("os");
-var import_node_path10 = require("path");
+var import_node_path9 = require("path");
 
 // ../shared/dist/node/provider-limits.js
 var import_node_child_process4 = require("child_process");
@@ -37968,6 +37969,7 @@ function mapProviderApiError(errorCode2, apiStatus) {
       return "model_mismatch";
     }
     if (code.includes("authentication") || code.includes("permission_error")) return "auth_invalid";
+    if (code.includes("quota_exceeded")) return "quota_exceeded";
     if (code.includes("rate_limit") || code.includes("resource_exhausted")) {
       return "rate_limited";
     }
@@ -47990,80 +47992,9 @@ ${result.stderr}`.trim();
 }
 
 // src/workspace-run-lease.ts
-var import_node_child_process6 = require("child_process");
-var import_promises5 = require("fs/promises");
-var import_node_path9 = require("path");
-
-// src/workspace-relocation.ts
 var import_node_child_process5 = require("child_process");
-var import_node_fs8 = require("fs");
+var import_promises5 = require("fs/promises");
 var import_node_path8 = require("path");
-var MAX_RELOCATION_CANDIDATES = 200;
-var DEFAULT_PROBE = {
-  childDirectories: (parentPath, limit) => (0, import_node_fs8.readdirSync)(parentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).slice(0, limit).map((entry) => (0, import_node_path8.join)(parentPath, entry.name)),
-  gitRemoteUrl: (candidatePath) => {
-    const result = (0, import_node_child_process5.spawnSync)("git", ["-C", candidatePath, "config", "--get", "remote.origin.url"], {
-      encoding: "utf8",
-      env: getDaemonCliEnvironment(),
-      timeout: 2e3
-    });
-    if (result.status !== 0) return null;
-    const url3 = result.stdout.trim();
-    return url3 || null;
-  }
-};
-function normalizeRepositoryIdentity(value2) {
-  const trimmed = value2.trim().replace(/\/+$/, "").replace(/\.git$/i, "");
-  if (!trimmed) return null;
-  const scp = trimmed.match(/^(?:[^@/]+@)?([^:/]+):(.+)$/);
-  if (scp && !trimmed.includes("://")) {
-    return `${scp[1]}/${scp[2]}`.toLowerCase();
-  }
-  try {
-    const url3 = new URL(trimmed);
-    return `${url3.hostname}${url3.pathname}`.replace(/\/+$/, "").toLowerCase();
-  } catch {
-    return null;
-  }
-}
-function workspaceMatchesExpectedRepositories(input2) {
-  const identities = new Set(
-    input2.expectedRepoUrls.map(normalizeRepositoryIdentity).filter((identity3) => Boolean(identity3))
-  );
-  if (identities.size === 0) return false;
-  const remote = (input2.probe ?? DEFAULT_PROBE).gitRemoteUrl((0, import_node_path8.resolve)(input2.workspacePath));
-  const identity2 = remote ? normalizeRepositoryIdentity(remote) : null;
-  return Boolean(identity2 && identities.has(identity2));
-}
-function discoverRelocatedWorkspace(input2) {
-  const identities = new Set(
-    input2.expectedRepoUrls.map(normalizeRepositoryIdentity).filter((identity2) => Boolean(identity2))
-  );
-  if (identities.size === 0) return null;
-  const searchRoots = [
-    (0, import_node_path8.dirname)((0, import_node_path8.resolve)(input2.missingPath)),
-    ...(input2.approvedWorkspacePaths ?? []).map((path2) => (0, import_node_path8.dirname)((0, import_node_path8.resolve)(path2)))
-  ].filter((path2, index, paths) => paths.indexOf(path2) === index);
-  const candidates = [];
-  for (const root of searchRoots) {
-    const remaining = MAX_RELOCATION_CANDIDATES - candidates.length;
-    if (remaining <= 0) break;
-    try {
-      candidates.push(...(input2.probe ?? DEFAULT_PROBE).childDirectories(root, remaining));
-    } catch {
-    }
-  }
-  const matches = [];
-  for (const candidate of new Set(candidates.map((path2) => (0, import_node_path8.resolve)(path2)))) {
-    const remote = (input2.probe ?? DEFAULT_PROBE).gitRemoteUrl(candidate);
-    const identity2 = remote ? normalizeRepositoryIdentity(remote) : null;
-    if (identity2 && identities.has(identity2)) matches.push((0, import_node_path8.resolve)(candidate));
-    if (matches.length > 1) return null;
-  }
-  return matches[0] ?? null;
-}
-
-// src/workspace-run-lease.ts
 var WORKSPACE_LEASE_CHECK_INTERVAL_MS = 1e3;
 function parsePositiveMs(value2, fallback) {
   const parsed = value2 ? Number(value2) : Number.NaN;
@@ -48079,19 +48010,19 @@ function applicationCodeForWorkspaceLeaseFailure(code) {
 async function hasGitWorkspaceMarker(workspacePath) {
   let directory;
   try {
-    directory = await (0, import_promises5.realpath)((0, import_node_path9.resolve)(workspacePath));
+    directory = await (0, import_promises5.realpath)((0, import_node_path8.resolve)(workspacePath));
   } catch {
     return true;
   }
   while (true) {
     try {
-      await (0, import_promises5.stat)((0, import_node_path9.join)(directory, ".git"));
+      await (0, import_promises5.stat)((0, import_node_path8.join)(directory, ".git"));
       return true;
     } catch (error61) {
       const code = error61.code;
       if (code !== "ENOENT" && code !== "ENOTDIR") return true;
     }
-    const parent = (0, import_node_path9.dirname)(directory);
+    const parent = (0, import_node_path8.dirname)(directory);
     if (parent === directory) return false;
     directory = parent;
   }
@@ -48103,7 +48034,7 @@ async function gitValue(cwd, args) {
   else runningGitProbes++;
   try {
     return await new Promise((resolve16) => {
-      (0, import_node_child_process6.execFile)(
+      (0, import_node_child_process5.execFile)(
         "git",
         ["-C", cwd, ...args],
         {
@@ -48129,7 +48060,7 @@ async function filesystemIdentity(path2) {
   return `${canonicalPath}:${metadata.dev}:${metadata.ino}`;
 }
 function resolveGitPath(workspacePath, value2) {
-  return (0, import_node_path9.isAbsolute)(value2) ? value2 : (0, import_node_path9.resolve)(workspacePath, value2);
+  return (0, import_node_path8.isAbsolute)(value2) ? value2 : (0, import_node_path8.resolve)(workspacePath, value2);
 }
 function createWorkspaceRunLeaseSnapshotProbe(loadSnapshot) {
   const snapshots = /* @__PURE__ */ new Map();
@@ -48151,7 +48082,7 @@ function createWorkspaceRunLeaseSnapshotProbe(loadSnapshot) {
     return pending.promise;
   };
   return (workspacePath, options) => {
-    const key = process.platform === "win32" ? (0, import_node_path9.resolve)(workspacePath).toLowerCase() : (0, import_node_path9.resolve)(workspacePath);
+    const key = process.platform === "win32" ? (0, import_node_path8.resolve)(workspacePath).toLowerCase() : (0, import_node_path8.resolve)(workspacePath);
     const existing = snapshots.get(key);
     if (!existing) return startSnapshot(key, options?.coalescePending === true);
     if (!options?.fresh) return existing.promise;
@@ -48164,11 +48095,11 @@ function createWorkspaceRunLeaseSnapshotProbe(loadSnapshot) {
     return existing.freshAfterPending;
   };
 }
-var DEFAULT_PROBE2 = {
+var DEFAULT_PROBE = {
   snapshot: createWorkspaceRunLeaseSnapshotProbe(snapshotWorkspace),
   pathExists: async (workspacePath) => {
     try {
-      await (0, import_promises5.access)((0, import_node_path9.resolve)(workspacePath));
+      await (0, import_promises5.access)((0, import_node_path8.resolve)(workspacePath));
       return true;
     } catch (error61) {
       return error61.code !== "ENOENT";
@@ -48177,7 +48108,7 @@ var DEFAULT_PROBE2 = {
 };
 async function snapshotWorkspace(workspacePath) {
   try {
-    const canonicalWorkspacePath = await (0, import_promises5.realpath)((0, import_node_path9.resolve)(workspacePath));
+    const canonicalWorkspacePath = await (0, import_promises5.realpath)((0, import_node_path8.resolve)(workspacePath));
     const repositoryRoot = await gitValue(canonicalWorkspacePath, ["rev-parse", "--show-toplevel"]);
     const gitDirectory = await gitValue(canonicalWorkspacePath, ["rev-parse", "--git-dir"]);
     const commonDirectory = await gitValue(canonicalWorkspacePath, [
@@ -48186,14 +48117,15 @@ async function snapshotWorkspace(workspacePath) {
     ]);
     const branch = await gitValue(canonicalWorkspacePath, ["branch", "--show-current"]) ?? "";
     if (!repositoryRoot || !gitDirectory || !commonDirectory) return null;
-    const remote = await gitValue(canonicalWorkspacePath, ["config", "--get", "remote.origin.url"]);
-    const remoteIdentity = remote ? normalizeRepositoryIdentity(remote) : null;
     return {
-      workspacePath: (0, import_node_path9.resolve)(workspacePath),
+      workspacePath: (0, import_node_path8.resolve)(workspacePath),
       workspaceIdentity: await filesystemIdentity(canonicalWorkspacePath),
-      repositoryIdentity: `${await filesystemIdentity(
+      // The common Git directory identifies the checkout. A coding agent may
+      // legitimately add or update origin without replacing that directory;
+      // treating remote configuration as filesystem identity stops its run.
+      repositoryIdentity: await filesystemIdentity(
         resolveGitPath(canonicalWorkspacePath, commonDirectory)
-      )}:${remoteIdentity ?? "local"}`,
+      ),
       worktreeIdentity: await filesystemIdentity(
         resolveGitPath(canonicalWorkspacePath, gitDirectory)
       ),
@@ -48229,10 +48161,10 @@ var WorkspaceRunLease = class _WorkspaceRunLease {
     this.captured = captured;
     this.probe = probe;
   }
-  static async capture(targets, probe = DEFAULT_PROBE2) {
+  static async capture(targets, probe = DEFAULT_PROBE) {
     const captured = [];
     for (const target of targets) {
-      const normalizedTarget = { ...target, workspacePath: (0, import_node_path9.resolve)(target.workspacePath) };
+      const normalizedTarget = { ...target, workspacePath: (0, import_node_path8.resolve)(target.workspacePath) };
       const identity2 = await probe.snapshot(normalizedTarget.workspacePath, {
         fresh: true,
         coalescePending: true
@@ -48775,13 +48707,13 @@ var DurablePendingRunStarts = class extends Map {
   }
   persist() {
     if (this.size === 0) {
-      (0, import_node_fs9.rmSync)(this.path, { force: true });
+      (0, import_node_fs8.rmSync)(this.path, { force: true });
       return;
     }
     const pendingPath = `${this.path}.pending`;
-    (0, import_node_fs9.mkdirSync)((0, import_node_path10.dirname)(this.path), { recursive: true, mode: 448 });
+    (0, import_node_fs8.mkdirSync)((0, import_node_path9.dirname)(this.path), { recursive: true, mode: 448 });
     try {
-      (0, import_node_fs9.writeFileSync)(
+      (0, import_node_fs8.writeFileSync)(
         pendingPath,
         JSON.stringify({
           version: 1,
@@ -48794,10 +48726,10 @@ var DurablePendingRunStarts = class extends Map {
         }),
         { mode: 384 }
       );
-      (0, import_node_fs9.chmodSync)(pendingPath, 384);
-      (0, import_node_fs9.renameSync)(pendingPath, this.path);
+      (0, import_node_fs8.chmodSync)(pendingPath, 384);
+      (0, import_node_fs8.renameSync)(pendingPath, this.path);
     } finally {
-      (0, import_node_fs9.rmSync)(pendingPath, { force: true });
+      (0, import_node_fs8.rmSync)(pendingPath, { force: true });
     }
   }
 };
@@ -49041,7 +48973,7 @@ function collectRuntimeMetadata() {
     metadata.cpuCores = cpuList.length;
   }
   try {
-    const disk = (0, import_node_fs9.statfsSync)((0, import_node_os5.homedir)());
+    const disk = (0, import_node_fs8.statfsSync)((0, import_node_os5.homedir)());
     metadata.diskFreeBytes = disk.bavail * disk.bsize;
     metadata.diskTotalBytes = disk.blocks * disk.bsize;
   } catch {
@@ -49248,12 +49180,12 @@ function getConfigPath() {
   return boundAgentConfigPath ?? process.env.ALAN_AGENT_CONFIG_PATH ?? resolveAgentConfigPath({ profile: "production" });
 }
 function getEndpointDefaultsPath() {
-  return process.env.ALAN_AGENT_ENDPOINTS_PATH ?? (0, import_node_path11.join)((0, import_node_path11.dirname)(getConfigPath()), "endpoints.json");
+  return process.env.ALAN_AGENT_ENDPOINTS_PATH ?? (0, import_node_path10.join)((0, import_node_path10.dirname)(getConfigPath()), "endpoints.json");
 }
 function readConfig() {
   const configPath = getConfigPath();
-  if (!(0, import_node_fs10.existsSync)(configPath)) return {};
-  const parsed = JSON.parse((0, import_node_fs10.readFileSync)(configPath, "utf8"));
+  if (!(0, import_node_fs9.existsSync)(configPath)) return {};
+  const parsed = JSON.parse((0, import_node_fs9.readFileSync)(configPath, "utf8"));
   const sanitized = sanitizeAgentConfig(parsed);
   if (Object.keys(parsed).some((key) => !Object.hasOwn(sanitized, key))) {
     writeConfig(sanitized);
@@ -49269,27 +49201,27 @@ function readConfigForRegistration() {
 }
 function readEndpointDefaults() {
   const endpointsPath = getEndpointDefaultsPath();
-  if (!(0, import_node_fs10.existsSync)(endpointsPath)) return {};
+  if (!(0, import_node_fs9.existsSync)(endpointsPath)) return {};
   try {
-    return JSON.parse((0, import_node_fs10.readFileSync)(endpointsPath, "utf8"));
+    return JSON.parse((0, import_node_fs9.readFileSync)(endpointsPath, "utf8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config2) {
   const configPath = getConfigPath();
-  (0, import_node_fs10.mkdirSync)((0, import_node_path11.dirname)(configPath), { recursive: true, mode: 448 });
+  (0, import_node_fs9.mkdirSync)((0, import_node_path10.dirname)(configPath), { recursive: true, mode: 448 });
   const pendingPath = `${configPath}.pending-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs10.writeFileSync)(
+    (0, import_node_fs9.writeFileSync)(
       pendingPath,
       JSON.stringify(sanitizeAgentConfig(config2), null, 2),
       { mode: 384 }
     );
-    (0, import_node_fs10.chmodSync)(pendingPath, 384);
-    (0, import_node_fs10.renameSync)(pendingPath, configPath);
+    (0, import_node_fs9.chmodSync)(pendingPath, 384);
+    (0, import_node_fs9.renameSync)(pendingPath, configPath);
   } finally {
-    (0, import_node_fs10.rmSync)(pendingPath, { force: true });
+    (0, import_node_fs9.rmSync)(pendingPath, { force: true });
   }
 }
 function maintenanceLeasePath(configPath) {
@@ -49297,9 +49229,9 @@ function maintenanceLeasePath(configPath) {
 }
 function readLocalDaemonMaintenanceLease(configPath, nowMs = Date.now()) {
   const path2 = maintenanceLeasePath(configPath);
-  if (!(0, import_node_fs10.existsSync)(path2)) return null;
+  if (!(0, import_node_fs9.existsSync)(path2)) return null;
   try {
-    const lease = JSON.parse((0, import_node_fs10.readFileSync)(path2, "utf8"));
+    const lease = JSON.parse((0, import_node_fs9.readFileSync)(path2, "utf8"));
     if (lease.version !== 1 || typeof lease.id !== "string" || lease.reason !== "credential_cleanup" && lease.reason !== "credential_swap" && lease.reason !== "daemon_startup" && lease.reason !== "watchdog" || !(lease.reason === "credential_cleanup" && lease.expiresAtMs === null || typeof lease.expiresAtMs === "number" && Number.isFinite(lease.expiresAtMs))) {
       throw new Error("invalid maintenance lease");
     }
@@ -49316,8 +49248,8 @@ function readLocalDaemonMaintenanceLease(configPath, nowMs = Date.now()) {
       expiresAtMs: nowMs + 5e3
     };
     try {
-      (0, import_node_fs10.writeFileSync)(path2, JSON.stringify(fallback), { mode: 384 });
-      (0, import_node_fs10.chmodSync)(path2, 384);
+      (0, import_node_fs9.writeFileSync)(path2, JSON.stringify(fallback), { mode: 384 });
+      (0, import_node_fs9.chmodSync)(path2, 384);
     } catch {
     }
     return fallback;
@@ -49333,10 +49265,10 @@ function acquireLocalDaemonMaintenanceLease(configPath, reason, ttlMs = 5e3) {
     expiresAtMs: reason === "credential_cleanup" ? null : Date.now() + Math.max(1e3, Math.min(ttlMs, 6e4))
   };
   const path2 = maintenanceLeasePath(configPath);
-  (0, import_node_fs10.mkdirSync)((0, import_node_path11.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs9.mkdirSync)((0, import_node_path10.dirname)(path2), { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs10.writeFileSync)(path2, JSON.stringify(lease), { mode: 384, flag: "wx" });
-    (0, import_node_fs10.chmodSync)(path2, 384);
+    (0, import_node_fs9.writeFileSync)(path2, JSON.stringify(lease), { mode: 384, flag: "wx" });
+    (0, import_node_fs9.chmodSync)(path2, 384);
     return { acquired: true, lease };
   } catch (error61) {
     const raced = readLocalDaemonMaintenanceLease(configPath);
@@ -49352,9 +49284,9 @@ function daemonOwnerLeasePath(configPath) {
 }
 function readLocalDaemonOwnerLease(configPath) {
   const path2 = daemonOwnerLeasePath(configPath);
-  if (!(0, import_node_fs10.existsSync)(path2)) return null;
+  if (!(0, import_node_fs9.existsSync)(path2)) return null;
   try {
-    const lease = JSON.parse((0, import_node_fs10.readFileSync)(path2, "utf8"));
+    const lease = JSON.parse((0, import_node_fs9.readFileSync)(path2, "utf8"));
     if (lease.version !== 1 || typeof lease.id !== "string" || typeof lease.daemonSessionId !== "string" || !Number.isSafeInteger(lease.pid) || lease.pid <= 0 || typeof lease.startedAtMs !== "number" || !Number.isFinite(lease.startedAtMs) || typeof lease.runtimeId !== "string" || typeof lease.localServiceId !== "string" || !Number.isSafeInteger(lease.localApiPort) || lease.localApiPort < 0 || lease.localApiPort > 65535 || typeof lease.localApiToken !== "string" || lease.localApiToken.length === 0) {
       throw new Error("invalid daemon owner lease");
     }
@@ -49409,10 +49341,10 @@ async function acquireLocalDaemonOwnerLease(input2) {
     localApiToken: input2.localApiToken
   };
   const path2 = daemonOwnerLeasePath(input2.configPath);
-  (0, import_node_fs10.mkdirSync)((0, import_node_path11.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs9.mkdirSync)((0, import_node_path10.dirname)(path2), { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs10.writeFileSync)(path2, JSON.stringify(lease), { mode: 384, flag: "wx" });
-    (0, import_node_fs10.chmodSync)(path2, 384);
+    (0, import_node_fs9.writeFileSync)(path2, JSON.stringify(lease), { mode: 384, flag: "wx" });
+    (0, import_node_fs9.chmodSync)(path2, 384);
     return { acquired: true, lease };
   } catch (error61) {
     const raced = readLocalDaemonOwnerLease(input2.configPath);
@@ -49427,12 +49359,12 @@ function updateLocalDaemonOwnerEndpoint(configPath, lease, localApiPort) {
   const path2 = daemonOwnerLeasePath(configPath);
   const pendingPath = `${path2}.pending-${lease.id}`;
   try {
-    (0, import_node_fs10.writeFileSync)(pendingPath, JSON.stringify(updated), { mode: 384 });
-    (0, import_node_fs10.chmodSync)(pendingPath, 384);
-    (0, import_node_fs10.renameSync)(pendingPath, path2);
+    (0, import_node_fs9.writeFileSync)(pendingPath, JSON.stringify(updated), { mode: 384 });
+    (0, import_node_fs9.chmodSync)(pendingPath, 384);
+    (0, import_node_fs9.renameSync)(pendingPath, path2);
     return updated;
   } finally {
-    (0, import_node_fs10.rmSync)(pendingPath, { force: true });
+    (0, import_node_fs9.rmSync)(pendingPath, { force: true });
   }
 }
 function releaseLocalDaemonOwnerLease(configPath, leaseId) {
@@ -49441,13 +49373,13 @@ function releaseLocalDaemonOwnerLease(configPath, leaseId) {
 function releaseOwnedJsonFile(path2, ownerId, ownerField = "id") {
   const releasePath = `${path2}.release-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs10.renameSync)(path2, releasePath);
+    (0, import_node_fs9.renameSync)(path2, releasePath);
   } catch (error61) {
     if (error61.code === "ENOENT") return;
     throw error61;
   }
   try {
-    const content = (0, import_node_fs10.readFileSync)(releasePath, "utf8");
+    const content = (0, import_node_fs9.readFileSync)(releasePath, "utf8");
     let capturedOwnerId = null;
     try {
       const captured = JSON.parse(content);
@@ -49456,13 +49388,13 @@ function releaseOwnedJsonFile(path2, ownerId, ownerField = "id") {
     }
     if (capturedOwnerId === ownerId) return;
     try {
-      (0, import_node_fs10.writeFileSync)(path2, content, { mode: 384, flag: "wx" });
-      (0, import_node_fs10.chmodSync)(path2, 384);
+      (0, import_node_fs9.writeFileSync)(path2, content, { mode: 384, flag: "wx" });
+      (0, import_node_fs9.chmodSync)(path2, 384);
     } catch (error61) {
       if (error61.code !== "EEXIST") throw error61;
     }
   } finally {
-    (0, import_node_fs10.rmSync)(releasePath, { force: true });
+    (0, import_node_fs9.rmSync)(releasePath, { force: true });
   }
 }
 function inspectLocalDaemonRunJournal(configPath) {
@@ -49472,8 +49404,8 @@ function inspectLocalDaemonRunJournal(configPath) {
   try {
     let activeRunCount = 0;
     for (const artifact of [path2, pendingPath]) {
-      if (!(0, import_node_fs10.existsSync)(artifact)) continue;
-      const parsed = JSON.parse((0, import_node_fs10.readFileSync)(artifact, "utf8"));
+      if (!(0, import_node_fs9.existsSync)(artifact)) continue;
+      const parsed = JSON.parse((0, import_node_fs9.readFileSync)(artifact, "utf8"));
       if (parsed.version !== 1 || !Array.isArray(parsed.entries))
         throw new Error("invalid journal");
       if (artifact === path2) {
@@ -49492,7 +49424,7 @@ function inspectLocalDaemonRunJournal(configPath) {
         }).length;
         continue;
       }
-      const legacyStartedAtMs = (0, import_node_fs10.statSync)(pendingPath).mtimeMs;
+      const legacyStartedAtMs = (0, import_node_fs9.statSync)(pendingPath).mtimeMs;
       activeRunCount += parsed.entries.filter((entry) => {
         if (!entry || typeof entry !== "object") throw new Error("invalid pending run entry");
         const startedAtMs = entry.startedAtMs;
@@ -49519,9 +49451,9 @@ function setupTokenHash(setupToken) {
 function getOrCreateSetupAttemptId(setupToken) {
   const intentPath = pendingSetupIntentPath();
   const tokenHash = setupTokenHash(setupToken);
-  if ((0, import_node_fs10.existsSync)(intentPath)) {
+  if ((0, import_node_fs9.existsSync)(intentPath)) {
     try {
-      const stored = JSON.parse((0, import_node_fs10.readFileSync)(intentPath, "utf8"));
+      const stored = JSON.parse((0, import_node_fs9.readFileSync)(intentPath, "utf8"));
       if (stored.setupTokenHash === tokenHash && typeof stored.registrationAttemptId === "string" && stored.registrationAttemptId.length > 0) {
         return stored.registrationAttemptId;
       }
@@ -49529,23 +49461,23 @@ function getOrCreateSetupAttemptId(setupToken) {
     }
   }
   const registrationAttemptId = (0, import_node_crypto5.randomUUID)();
-  (0, import_node_fs10.mkdirSync)((0, import_node_path11.dirname)(intentPath), { recursive: true, mode: 448 });
+  (0, import_node_fs9.mkdirSync)((0, import_node_path10.dirname)(intentPath), { recursive: true, mode: 448 });
   const writePath = `${intentPath}.pending-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs10.writeFileSync)(
+    (0, import_node_fs9.writeFileSync)(
       writePath,
       JSON.stringify({ setupTokenHash: tokenHash, registrationAttemptId }, null, 2),
       { mode: 384 }
     );
-    (0, import_node_fs10.chmodSync)(writePath, 384);
-    (0, import_node_fs10.renameSync)(writePath, intentPath);
+    (0, import_node_fs9.chmodSync)(writePath, 384);
+    (0, import_node_fs9.renameSync)(writePath, intentPath);
   } finally {
-    (0, import_node_fs10.rmSync)(writePath, { force: true });
+    (0, import_node_fs9.rmSync)(writePath, { force: true });
   }
   return registrationAttemptId;
 }
 function clearPendingSetupIntent() {
-  (0, import_node_fs10.rmSync)(pendingSetupIntentPath(), { force: true });
+  (0, import_node_fs9.rmSync)(pendingSetupIntentPath(), { force: true });
 }
 function pendingDeviceAuthorizationPath() {
   return `${getConfigPath()}.device-auth-pending`;
@@ -49566,8 +49498,8 @@ function parseDeviceAuthorizationOperationContent(content) {
 }
 function restoreCapturedFileUnlessReplaced(path2, content) {
   try {
-    (0, import_node_fs10.writeFileSync)(path2, content, { mode: 384, flag: "wx" });
-    (0, import_node_fs10.chmodSync)(path2, 384);
+    (0, import_node_fs9.writeFileSync)(path2, content, { mode: 384, flag: "wx" });
+    (0, import_node_fs9.chmodSync)(path2, 384);
   } catch (error61) {
     if (error61.code !== "EEXIST") throw error61;
   }
@@ -49575,26 +49507,26 @@ function restoreCapturedFileUnlessReplaced(path2, content) {
 function quarantineCorruptDeviceAuthorizationOperation(path2) {
   const quarantinePath = `${path2}.corrupt-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs10.renameSync)(path2, quarantinePath);
+    (0, import_node_fs9.renameSync)(path2, quarantinePath);
   } catch (error61) {
     if (error61.code === "ENOENT") return null;
     throw error61;
   }
   try {
-    const capturedContent = (0, import_node_fs10.readFileSync)(quarantinePath, "utf8");
+    const capturedContent = (0, import_node_fs9.readFileSync)(quarantinePath, "utf8");
     if (parseDeviceAuthorizationOperationContent(capturedContent)) {
       restoreCapturedFileUnlessReplaced(path2, capturedContent);
     }
   } finally {
-    (0, import_node_fs10.rmSync)(quarantinePath, { force: true });
+    (0, import_node_fs9.rmSync)(quarantinePath, { force: true });
   }
-  if (!(0, import_node_fs10.existsSync)(path2)) return null;
-  return parseDeviceAuthorizationOperationContent((0, import_node_fs10.readFileSync)(path2, "utf8"));
+  if (!(0, import_node_fs9.existsSync)(path2)) return null;
+  return parseDeviceAuthorizationOperationContent((0, import_node_fs9.readFileSync)(path2, "utf8"));
 }
 function readDeviceAuthorizationOperation() {
   const path2 = deviceAuthorizationOperationPath();
-  if (!(0, import_node_fs10.existsSync)(path2)) return null;
-  const parsed = parseDeviceAuthorizationOperationContent((0, import_node_fs10.readFileSync)(path2, "utf8"));
+  if (!(0, import_node_fs9.existsSync)(path2)) return null;
+  const parsed = parseDeviceAuthorizationOperationContent((0, import_node_fs9.readFileSync)(path2, "utf8"));
   const lease = parsed ?? quarantineCorruptDeviceAuthorizationOperation(path2);
   if (!lease) return null;
   if (lease.expiresAtMs <= Date.now()) {
@@ -49612,10 +49544,10 @@ function acquireDeviceAuthorizationOperation() {
     expiresAtMs: Date.now() + 6e4
   };
   const path2 = deviceAuthorizationOperationPath();
-  (0, import_node_fs10.mkdirSync)((0, import_node_path11.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs9.mkdirSync)((0, import_node_path10.dirname)(path2), { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs10.writeFileSync)(path2, JSON.stringify(lease), { mode: 384, flag: "wx" });
-    (0, import_node_fs10.chmodSync)(path2, 384);
+    (0, import_node_fs9.writeFileSync)(path2, JSON.stringify(lease), { mode: 384, flag: "wx" });
+    (0, import_node_fs9.chmodSync)(path2, 384);
     return lease;
   } catch (error61) {
     if (error61.code === "EEXIST") return null;
@@ -49630,15 +49562,15 @@ function extendDeviceAuthorizationOperation(operationId, expiresAtMs) {
   const path2 = deviceAuthorizationOperationPath();
   const pendingPath = `${path2}.pending-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs10.writeFileSync)(
+    (0, import_node_fs9.writeFileSync)(
       pendingPath,
       JSON.stringify({ ...current, expiresAtMs: Math.max(expiresAtMs, Date.now() + 6e4) }),
       { mode: 384 }
     );
-    (0, import_node_fs10.chmodSync)(pendingPath, 384);
-    (0, import_node_fs10.renameSync)(pendingPath, path2);
+    (0, import_node_fs9.chmodSync)(pendingPath, 384);
+    (0, import_node_fs9.renameSync)(pendingPath, path2);
   } finally {
-    (0, import_node_fs10.rmSync)(pendingPath, { force: true });
+    (0, import_node_fs9.rmSync)(pendingPath, { force: true });
   }
 }
 function assertDeviceAuthorizationOperationOwner(operationId) {
@@ -49649,12 +49581,12 @@ function assertDeviceAuthorizationOperationOwner(operationId) {
 function clearPendingDeviceAuthorization(operationId) {
   const path2 = pendingDeviceAuthorizationPath();
   if (!operationId) {
-    (0, import_node_fs10.rmSync)(path2, { force: true });
+    (0, import_node_fs9.rmSync)(path2, { force: true });
     return;
   }
-  if (!(0, import_node_fs10.existsSync)(path2)) return;
+  if (!(0, import_node_fs9.existsSync)(path2)) return;
   try {
-    const pending = JSON.parse((0, import_node_fs10.readFileSync)(path2, "utf8"));
+    const pending = JSON.parse((0, import_node_fs9.readFileSync)(path2, "utf8"));
     if (pending.operationId !== operationId) return;
   } catch {
     return;
@@ -49663,9 +49595,9 @@ function clearPendingDeviceAuthorization(operationId) {
 }
 function readPendingDeviceAuthorization(apiUrl) {
   const path2 = pendingDeviceAuthorizationPath();
-  if (!(0, import_node_fs10.existsSync)(path2)) return null;
+  if (!(0, import_node_fs9.existsSync)(path2)) return null;
   try {
-    const pending = JSON.parse((0, import_node_fs10.readFileSync)(path2, "utf8"));
+    const pending = JSON.parse((0, import_node_fs9.readFileSync)(path2, "utf8"));
     const expiresAtMs = Date.parse(pending.expiresAt ?? "");
     if (pending.apiUrl !== apiUrl || typeof pending.deviceCode !== "string" || typeof pending.userCode !== "string" || typeof pending.verificationUri !== "string" || typeof pending.installationId !== "string" || pending.operationId !== void 0 && typeof pending.operationId !== "string" || !Number.isFinite(pending.intervalSeconds) || !Number.isFinite(expiresAtMs) || expiresAtMs <= Date.now()) {
       return null;
@@ -49677,20 +49609,20 @@ function readPendingDeviceAuthorization(apiUrl) {
 }
 function writePendingDeviceAuthorization(pending) {
   const path2 = pendingDeviceAuthorizationPath();
-  (0, import_node_fs10.mkdirSync)((0, import_node_path11.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs9.mkdirSync)((0, import_node_path10.dirname)(path2), { recursive: true, mode: 448 });
   const writePath = `${path2}.pending-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs10.writeFileSync)(writePath, JSON.stringify(pending, null, 2), { mode: 384 });
-    (0, import_node_fs10.chmodSync)(writePath, 384);
-    (0, import_node_fs10.renameSync)(writePath, path2);
+    (0, import_node_fs9.writeFileSync)(writePath, JSON.stringify(pending, null, 2), { mode: 384 });
+    (0, import_node_fs9.chmodSync)(writePath, 384);
+    (0, import_node_fs9.renameSync)(writePath, path2);
   } finally {
-    (0, import_node_fs10.rmSync)(writePath, { force: true });
+    (0, import_node_fs9.rmSync)(writePath, { force: true });
   }
 }
 function removeAlanOwnedLocalArtifacts() {
   const configPath = getConfigPath();
-  const directory = (0, import_node_path11.dirname)(configPath);
-  const configName = (0, import_node_path11.basename)(configPath).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const directory = (0, import_node_path10.dirname)(configPath);
+  const configName = (0, import_node_path10.basename)(configPath).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const alanAtomicSidecarPattern = new RegExp(
     `^${configName}(?:|\\.setup-pending|\\.device-auth-pending|\\.device-auth-operation\\.json|\\.maintenance-lease\\.json|\\.event-outbox\\.enc)\\.(?:pending|release|corrupt)-\\d+-[a-f0-9]{12}$`
   );
@@ -49707,19 +49639,26 @@ function removeAlanOwnedLocalArtifacts() {
     `${configPath}.pending-runs.json.pending`,
     maintenanceLeasePath(configPath)
   ]);
-  if ((0, import_node_fs10.existsSync)(directory)) {
-    for (const entry of (0, import_node_fs10.readdirSync)(directory)) {
-      if (alanAtomicSidecarPattern.test(entry)) artifacts.add((0, import_node_path11.join)(directory, entry));
+  if ((0, import_node_fs9.existsSync)(directory)) {
+    for (const entry of (0, import_node_fs9.readdirSync)(directory)) {
+      if (alanAtomicSidecarPattern.test(entry)) artifacts.add((0, import_node_path10.join)(directory, entry));
     }
   }
-  for (const artifact of artifacts) (0, import_node_fs10.rmSync)(artifact, { force: true });
-  (0, import_node_fs10.rmSync)(configPath, { force: true });
+  for (const artifact of artifacts) (0, import_node_fs9.rmSync)(artifact, { force: true });
+  for (const encryptedDirectory of [
+    `${configPath}.event-outbox.enc.journal`,
+    `${configPath}.native-streams`,
+    (0, import_node_path10.join)(directory, "native-hook-inbox")
+  ]) {
+    (0, import_node_fs9.rmSync)(encryptedDirectory, { recursive: true, force: true });
+  }
+  (0, import_node_fs9.rmSync)(configPath, { force: true });
 }
 
 // src/provider-model-discovery.ts
-var import_node_fs11 = require("fs");
+var import_node_fs10 = require("fs");
 var import_node_os6 = require("os");
-var import_node_path12 = require("path");
+var import_node_path11 = require("path");
 var MODEL_DISCOVERY_TIMEOUT_MS = 8e3;
 var ANTIGRAVITY_MODEL_DISCOVERY_TIMEOUT_MS = 12e3;
 var OPENCODE_ZEN_MODEL_IDS = OPENCODE_ZEN_MODELS.map((model) => model.id);
@@ -49931,7 +49870,7 @@ function filterClaudeDatedModelIds(ids) {
 }
 function resolveExecutableForModelScan(executable) {
   try {
-    return (0, import_node_fs11.realpathSync)(executable);
+    return (0, import_node_fs10.realpathSync)(executable);
   } catch {
     return executable;
   }
@@ -49939,7 +49878,7 @@ function resolveExecutableForModelScan(executable) {
 function extractClaudeModelIdsFromExecutable(executable) {
   try {
     const resolved = resolveExecutableForModelScan(executable);
-    const text = (0, import_node_fs11.readFileSync)(resolved).toString("latin1");
+    const text = (0, import_node_fs10.readFileSync)(resolved).toString("latin1");
     const matches = text.match(CLAUDE_MODEL_ID_PATTERN) ?? [];
     const unique2 = [
       ...new Set(matches.map((id) => id.trim()).filter((id) => isValidClaudeModelId(id))),
@@ -49998,9 +49937,9 @@ function readOpenCodeZenCredential(env) {
 function readOpenCodeAuthDocument(env) {
   const injected = env.OPENCODE_AUTH_CONTENT?.trim();
   if (injected) return injected;
-  const dataHome = env.XDG_DATA_HOME?.trim() || (0, import_node_path12.join)((0, import_node_os6.homedir)(), ".local", "share");
+  const dataHome = env.XDG_DATA_HOME?.trim() || (0, import_node_path11.join)((0, import_node_os6.homedir)(), ".local", "share");
   try {
-    return (0, import_node_fs11.readFileSync)((0, import_node_path12.join)(dataHome, "opencode", "auth.json"), "utf8");
+    return (0, import_node_fs10.readFileSync)((0, import_node_path11.join)(dataHome, "opencode", "auth.json"), "utf8");
   } catch {
     return null;
   }
@@ -50083,11 +50022,11 @@ function applyZenEntitlement(discovery, entitled) {
 var OPENCODE_CATALOGUE_CACHE_SEGMENTS = ["opencode", "models.json"];
 var OPENCODE_CACHE_PROVIDER_KEYS = ["opencode", "opencode-go"];
 function readOpenCodeCatalogueCache(env) {
-  const cacheHome = env.XDG_CACHE_HOME?.trim() || (0, import_node_path12.join)((0, import_node_os6.homedir)(), ".cache");
+  const cacheHome = env.XDG_CACHE_HOME?.trim() || (0, import_node_path11.join)((0, import_node_os6.homedir)(), ".cache");
   let parsed;
   try {
     parsed = JSON.parse(
-      (0, import_node_fs11.readFileSync)((0, import_node_path12.join)(cacheHome, ...OPENCODE_CATALOGUE_CACHE_SEGMENTS), "utf8")
+      (0, import_node_fs10.readFileSync)((0, import_node_path11.join)(cacheHome, ...OPENCODE_CATALOGUE_CACHE_SEGMENTS), "utf8")
     );
   } catch {
     return null;
@@ -54250,11 +54189,11 @@ Object.assign(lookup, {
 });
 
 // src/binding-switch-git.ts
-var import_node_child_process7 = require("child_process");
+var import_node_child_process6 = require("child_process");
 var import_node_crypto6 = require("crypto");
-var import_node_fs12 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_os7 = require("os");
-var import_node_path13 = require("path");
+var import_node_path12 = require("path");
 var import_node_url = require("url");
 var BINDING_SWITCH_GIT_METHODS = [
   "git.status",
@@ -54279,7 +54218,7 @@ var LOCAL_GIT_TIMEOUT_MS = 1e4;
 var NETWORK_GIT_TIMEOUT_MS = 3e4;
 var MAX_GIT_OUTPUT_BYTES = 10 * 1024 * 1024;
 function runGitResult(cwd, args, options = {}) {
-  const result = (0, import_node_child_process7.spawnSync)("git", args, {
+  const result = (0, import_node_child_process6.spawnSync)("git", args, {
     cwd,
     env: { ...getDaemonCliEnvironment(), ...options.env },
     encoding: "utf8",
@@ -54304,12 +54243,12 @@ function networkGitTimeoutMs() {
 async function waitForCheckpointTestBarrier() {
   const barrierDir = process.env.NODE_ENV === "test" ? process.env.ALAN_TEST_GIT_CHECKPOINT_BARRIER_DIR : void 0;
   if (!barrierDir) return;
-  (0, import_node_fs12.mkdirSync)(barrierDir, { recursive: true });
-  const readyPath = (0, import_node_path13.join)(barrierDir, "ready");
-  const releasePath = (0, import_node_path13.join)(barrierDir, "release");
-  (0, import_node_fs12.writeFileSync)(readyPath, "ready\n");
+  (0, import_node_fs11.mkdirSync)(barrierDir, { recursive: true });
+  const readyPath = (0, import_node_path12.join)(barrierDir, "ready");
+  const releasePath = (0, import_node_path12.join)(barrierDir, "release");
+  (0, import_node_fs11.writeFileSync)(readyPath, "ready\n");
   const deadline = Date.now() + 5e3;
-  while (!(0, import_node_fs12.existsSync)(releasePath)) {
+  while (!(0, import_node_fs11.existsSync)(releasePath)) {
     if (Date.now() >= deadline) {
       throw new BindingSwitchGitError(
         "checkpoint_prepare_timeout",
@@ -54322,12 +54261,12 @@ async function waitForCheckpointTestBarrier() {
 async function waitForCheckpointFinalizeTestBarrier() {
   const barrierDir = process.env.NODE_ENV === "test" ? process.env.ALAN_TEST_GIT_CHECKPOINT_FINALIZE_BARRIER_DIR : void 0;
   if (!barrierDir) return;
-  (0, import_node_fs12.mkdirSync)(barrierDir, { recursive: true });
-  const readyPath = (0, import_node_path13.join)(barrierDir, "ready");
-  const releasePath = (0, import_node_path13.join)(barrierDir, "release");
-  (0, import_node_fs12.writeFileSync)(readyPath, "ready\n");
+  (0, import_node_fs11.mkdirSync)(barrierDir, { recursive: true });
+  const readyPath = (0, import_node_path12.join)(barrierDir, "ready");
+  const releasePath = (0, import_node_path12.join)(barrierDir, "release");
+  (0, import_node_fs11.writeFileSync)(readyPath, "ready\n");
   const deadline = Date.now() + 5e3;
-  while (!(0, import_node_fs12.existsSync)(releasePath)) {
+  while (!(0, import_node_fs11.existsSync)(releasePath)) {
     if (Date.now() >= deadline) {
       throw new BindingSwitchGitError(
         "checkpoint_finalize_timeout",
@@ -54339,7 +54278,7 @@ async function waitForCheckpointFinalizeTestBarrier() {
 }
 async function runNetworkGit(cwd, args, code) {
   return new Promise((resolvePromise, rejectPromise) => {
-    const child = (0, import_node_child_process7.spawn)("git", args, {
+    const child = (0, import_node_child_process6.spawn)("git", args, {
       cwd,
       env: {
         ...getDaemonCliEnvironment(),
@@ -54440,7 +54379,7 @@ function sourceChangedDuringCheckpoint(message) {
 }
 function acquireCheckpointHeadLock(locks) {
   try {
-    (0, import_node_fs12.writeFileSync)(locks.headLockPath, "", { flag: "wx" });
+    (0, import_node_fs11.writeFileSync)(locks.headLockPath, "", { flag: "wx" });
     locks.headLockHeld = true;
   } catch {
     throw sourceChangedDuringCheckpoint(
@@ -54450,7 +54389,7 @@ function acquireCheckpointHeadLock(locks) {
 }
 function releaseCheckpointHeadLock(locks) {
   if (!locks.headLockHeld) return;
-  (0, import_node_fs12.rmSync)(locks.headLockPath, { force: true });
+  (0, import_node_fs11.rmSync)(locks.headLockPath, { force: true });
   locks.headLockHeld = false;
 }
 function acquireCheckpointRepositoryLocks(repoRoot) {
@@ -54465,20 +54404,20 @@ function acquireCheckpointRepositoryLocks(repoRoot) {
     "checkpoint_lock_unavailable"
   );
   const locks = {
-    headLockPath: (0, import_node_path13.join)(gitDir, "HEAD.lock"),
+    headLockPath: (0, import_node_path12.join)(gitDir, "HEAD.lock"),
     headLockHeld: false,
     indexLockPath: `${indexPath}.lock`,
     indexLockHeld: false,
     indexPath
   };
   try {
-    (0, import_node_fs12.writeFileSync)(locks.indexLockPath, "", { flag: "wx" });
+    (0, import_node_fs11.writeFileSync)(locks.indexLockPath, "", { flag: "wx" });
     locks.indexLockHeld = true;
     acquireCheckpointHeadLock(locks);
     return locks;
   } catch {
     if (locks.indexLockHeld) {
-      (0, import_node_fs12.rmSync)(locks.indexLockPath, { force: true });
+      (0, import_node_fs11.rmSync)(locks.indexLockPath, { force: true });
       locks.indexLockHeld = false;
     }
     throw sourceChangedDuringCheckpoint(
@@ -54489,7 +54428,7 @@ function acquireCheckpointRepositoryLocks(repoRoot) {
 function releaseCheckpointRepositoryLocks(locks) {
   releaseCheckpointHeadLock(locks);
   if (locks.indexLockHeld) {
-    (0, import_node_fs12.rmSync)(locks.indexLockPath, { force: true });
+    (0, import_node_fs11.rmSync)(locks.indexLockPath, { force: true });
     locks.indexLockHeld = false;
   }
 }
@@ -54507,8 +54446,8 @@ function assertCheckpointHead(repoRoot, expectedRef, expectedHeadSha) {
   }
 }
 function createCheckpointIndexBaseline(repoRoot, checkpointSha) {
-  const tempDir = (0, import_node_fs12.mkdtempSync)((0, import_node_path13.join)((0, import_node_os7.tmpdir)(), "alan-checkpoint-index-"));
-  const indexPath = (0, import_node_path13.join)(tempDir, "index");
+  const tempDir = (0, import_node_fs11.mkdtempSync)((0, import_node_path12.join)((0, import_node_os7.tmpdir)(), "alan-checkpoint-index-"));
+  const indexPath = (0, import_node_path12.join)(tempDir, "index");
   try {
     runGitWithOptions(
       repoRoot,
@@ -54518,14 +54457,14 @@ function createCheckpointIndexBaseline(repoRoot, checkpointSha) {
     );
     return { indexPath, tempDir };
   } catch (error61) {
-    (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
+    (0, import_node_fs11.rmSync)(tempDir, { recursive: true, force: true });
     throw error61;
   }
 }
 function installCheckpointIndexBaseline(locks, baselineIndexPath) {
   try {
-    (0, import_node_fs12.copyFileSync)(baselineIndexPath, locks.indexLockPath);
-    (0, import_node_fs12.renameSync)(locks.indexLockPath, locks.indexPath);
+    (0, import_node_fs11.copyFileSync)(baselineIndexPath, locks.indexLockPath);
+    (0, import_node_fs11.renameSync)(locks.indexLockPath, locks.indexPath);
     locks.indexLockHeld = false;
   } catch (error61) {
     throw new BindingSwitchGitError(
@@ -54569,7 +54508,7 @@ function commonRequest(params) {
   return {
     switchId: requiredString2(params, "switchId"),
     repoKey: requiredString2(params, "repoKey"),
-    repoPath: (0, import_node_path13.resolve)(requiredString2(params, "repoPath"))
+    repoPath: (0, import_node_path12.resolve)(requiredString2(params, "repoPath"))
   };
 }
 function assertCommitSha(sha, key) {
@@ -54581,7 +54520,7 @@ function assertValidBranch(branch) {
   if (branch.startsWith("-")) {
     throw new BindingSwitchGitError("invalid_git_request", "branch is not a safe Git ref");
   }
-  const result = (0, import_node_child_process7.spawnSync)("git", ["check-ref-format", "--branch", branch], {
+  const result = (0, import_node_child_process6.spawnSync)("git", ["check-ref-format", "--branch", branch], {
     env: getDaemonCliEnvironment(),
     encoding: "utf8"
   });
@@ -54603,8 +54542,8 @@ function canonicalRemoteUrl(repoRoot, value2) {
   }
   const scpStyle = trimmed.match(/^([^/@:\s]+)@([^/:\s]+):(.+)$/);
   const urlValue = scpStyle ? `ssh://${scpStyle[1]}@${scpStyle[2]}/${scpStyle[3]}` : trimmed;
-  if ((0, import_node_path13.isAbsolute)(urlValue) || urlValue.startsWith("./") || urlValue.startsWith("../")) {
-    const absolute = (0, import_node_path13.isAbsolute)(urlValue) ? urlValue : (0, import_node_path13.resolve)(repoRoot, urlValue);
+  if ((0, import_node_path12.isAbsolute)(urlValue) || urlValue.startsWith("./") || urlValue.startsWith("../")) {
+    const absolute = (0, import_node_path12.isAbsolute)(urlValue) ? urlValue : (0, import_node_path12.resolve)(repoRoot, urlValue);
     return `file://${canonicalPathWithMissingTail(absolute).replace(/\/+$/, "").replace(/\.git$/, "")}`;
   }
   let parsed;
@@ -54671,22 +54610,22 @@ function inspectedRemoteUrl(repoRoot, params) {
 }
 function canonicalPathWithMissingTail(path2) {
   const missingSegments = [];
-  let cursor2 = (0, import_node_path13.resolve)(path2);
-  while (!(0, import_node_fs12.existsSync)(cursor2)) {
-    const parent = (0, import_node_path13.dirname)(cursor2);
+  let cursor2 = (0, import_node_path12.resolve)(path2);
+  while (!(0, import_node_fs11.existsSync)(cursor2)) {
+    const parent = (0, import_node_path12.dirname)(cursor2);
     if (parent === cursor2) {
       throw new BindingSwitchGitError(
         "path_canonicalization_failed",
         "The selected path has no existing canonical ancestor"
       );
     }
-    missingSegments.unshift((0, import_node_path13.basename)(cursor2));
+    missingSegments.unshift((0, import_node_path12.basename)(cursor2));
     cursor2 = parent;
   }
-  return (0, import_node_path13.join)(import_node_fs12.realpathSync.native(cursor2), ...missingSegments);
+  return (0, import_node_path12.join)(import_node_fs11.realpathSync.native(cursor2), ...missingSegments);
 }
 function resolveRepositoryRoot(requestedPath) {
-  if (!(0, import_node_fs12.existsSync)(requestedPath)) {
+  if (!(0, import_node_fs11.existsSync)(requestedPath)) {
     throw new BindingSwitchGitError(
       "repository_not_found",
       `The selected repository path does not exist: ${requestedPath}`
@@ -54699,7 +54638,7 @@ function resolveRepositoryRoot(requestedPath) {
       "The selected folder is not inside a Git repository"
     );
   }
-  return import_node_fs12.realpathSync.native((0, import_node_path13.resolve)(root.stdout.trim()));
+  return import_node_fs11.realpathSync.native((0, import_node_path12.resolve)(root.stdout.trim()));
 }
 function listWorktrees(repoRoot) {
   return runGit(repoRoot, ["worktree", "list", "--porcelain"]).split("\n\n").flatMap((entry) => {
@@ -54718,7 +54657,7 @@ function resolveAuthorizedRepository(params, requireTrustedContext = false) {
   const { repoPath } = commonRequest(params);
   const repoRoot = resolveRepositoryRoot(repoPath);
   const expectedRepoRoot = requireTrustedContext ? requiredString2(params, "expectedRepoRoot") : optionalString(params, "expectedRepoRoot");
-  if (expectedRepoRoot && resolveRepositoryRoot((0, import_node_path13.resolve)(expectedRepoRoot)) !== repoRoot) {
+  if (expectedRepoRoot && resolveRepositoryRoot((0, import_node_path12.resolve)(expectedRepoRoot)) !== repoRoot) {
     throw new BindingSwitchGitError(
       "repository_path_changed",
       "The selected path now resolves to a different Git repository"
@@ -54726,7 +54665,7 @@ function resolveAuthorizedRepository(params, requireTrustedContext = false) {
   }
   const projectPath = requireTrustedContext ? requiredString2(params, "projectPath") : optionalString(params, "projectPath");
   if (!projectPath) return repoRoot;
-  const projectRoot = resolveRepositoryRoot((0, import_node_path13.resolve)(projectPath));
+  const projectRoot = resolveRepositoryRoot((0, import_node_path12.resolve)(projectPath));
   const registrations = listWorktrees(projectRoot);
   const registered = registrations.find(({ path: path2 }) => path2 === repoRoot);
   if (!registered) {
@@ -54755,8 +54694,8 @@ function updateLengthPrefixed(hash2, value2) {
   hash2.update("\0");
 }
 function proposedTreeSha(repoRoot, headSha) {
-  const tempDir = (0, import_node_fs12.mkdtempSync)((0, import_node_path13.join)((0, import_node_os7.tmpdir)(), "alan-switch-index-"));
-  const indexPath = (0, import_node_path13.join)(tempDir, "index");
+  const tempDir = (0, import_node_fs11.mkdtempSync)((0, import_node_path12.join)((0, import_node_os7.tmpdir)(), "alan-switch-index-"));
+  const indexPath = (0, import_node_path12.join)(tempDir, "index");
   const options = { env: { GIT_INDEX_FILE: indexPath } };
   try {
     if (headSha) {
@@ -54769,7 +54708,7 @@ function proposedTreeSha(repoRoot, headSha) {
     assertCommitSha(treeSha, "proposedTreeSha");
     return treeSha;
   } finally {
-    (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
+    (0, import_node_fs11.rmSync)(tempDir, { recursive: true, force: true });
   }
 }
 function statusFingerprint(repoRoot, porcelain, proposedTree) {
@@ -54905,7 +54844,7 @@ async function checkpoint(params) {
       return { repoRoot, sha: status.headSha, replayed: true };
     } finally {
       if (locks2) releaseCheckpointRepositoryLocks(locks2);
-      (0, import_node_fs12.rmSync)(baseline2.tempDir, { recursive: true, force: true });
+      (0, import_node_fs11.rmSync)(baseline2.tempDir, { recursive: true, force: true });
     }
   }
   assertSourcePreconditions(status, expectedHeadSha, expectedStatusFingerprint, expectedBranch);
@@ -55013,7 +54952,7 @@ Alan-Repository-Id: ${repoKey}`;
       runGitResult(repoRoot, ["update-ref", expectedRef, expectedHeadSha, sha]);
     }
     if (locks) releaseCheckpointRepositoryLocks(locks);
-    (0, import_node_fs12.rmSync)(baseline.tempDir, { recursive: true, force: true });
+    (0, import_node_fs11.rmSync)(baseline.tempDir, { recursive: true, force: true });
   }
 }
 function resolveRemoteBranch(repoRoot, params) {
@@ -55251,10 +55190,10 @@ var import_node_fs15 = require("fs");
 var import_node_path16 = require("path");
 
 // src/cli-ensure-install.ts
-var import_node_child_process8 = require("child_process");
-var import_node_fs13 = require("fs");
+var import_node_child_process7 = require("child_process");
+var import_node_fs12 = require("fs");
 var import_node_os8 = require("os");
-var import_node_path14 = require("path");
+var import_node_path13 = require("path");
 var CLI_RUNTIME_VERSIONS_ENV = "ALAN_CLI_RUNTIME_VERSIONS";
 var installOutcomes = /* @__PURE__ */ new Map();
 function canInstallProviderCli(backendKind) {
@@ -55271,14 +55210,14 @@ function currentRuntimePlatform() {
 }
 function resolveWindowsNpmInvocation(env, npmArgs) {
   const searchPath = env.PATH ?? env.Path ?? "";
-  for (const rawDirectory of searchPath.split(import_node_path14.delimiter)) {
+  for (const rawDirectory of searchPath.split(import_node_path13.delimiter)) {
     const directory = rawDirectory.trim().replace(/^"|"$/g, "");
     if (!directory) continue;
-    const executable = (0, import_node_path14.join)(directory, "npm.exe");
-    if ((0, import_node_fs13.existsSync)(executable)) return { command: executable, args: npmArgs };
-    const commandShim = (0, import_node_path14.join)(directory, "npm.cmd");
-    const cliScript = (0, import_node_path14.join)(directory, "node_modules", "npm", "bin", "npm-cli.js");
-    if ((0, import_node_fs13.existsSync)(commandShim) && (0, import_node_fs13.existsSync)(cliScript)) {
+    const executable = (0, import_node_path13.join)(directory, "npm.exe");
+    if ((0, import_node_fs12.existsSync)(executable)) return { command: executable, args: npmArgs };
+    const commandShim = (0, import_node_path13.join)(directory, "npm.cmd");
+    const cliScript = (0, import_node_path13.join)(directory, "node_modules", "npm", "bin", "npm-cli.js");
+    if ((0, import_node_fs12.existsSync)(commandShim) && (0, import_node_fs12.existsSync)(cliScript)) {
       return { command: process.execPath, args: [cliScript, ...npmArgs] };
     }
   }
@@ -55300,7 +55239,7 @@ function runNpmInstall(installSpec, env, timeoutMs) {
         });
         return;
       }
-      child = (0, import_node_child_process8.spawn)(invocation.command, invocation.args, {
+      child = (0, import_node_child_process7.spawn)(invocation.command, invocation.args, {
         env,
         windowsHide: isWin ? true : void 0,
         timeout: timeoutMs,
@@ -55383,25 +55322,25 @@ var import_node_os10 = require("os");
 
 // src/antigravity-api-key-config.ts
 var import_node_crypto7 = require("crypto");
-var import_node_fs14 = require("fs");
+var import_node_fs13 = require("fs");
 var import_node_os9 = require("os");
-var import_node_path15 = require("path");
+var import_node_path14 = require("path");
 var CONFIG_LOCK_STALE_MS = 3e4;
 var CONFIG_LOCK_WAIT_MS = 2e3;
 var CONFIG_LOCK_POLL_MS = 20;
 async function waitForConfigLock(lockPath) {
-  (0, import_node_fs14.mkdirSync)((0, import_node_path15.dirname)(lockPath), { recursive: true });
+  (0, import_node_fs13.mkdirSync)((0, import_node_path14.dirname)(lockPath), { recursive: true });
   const startedAt = Date.now();
   while (true) {
     try {
-      (0, import_node_fs14.mkdirSync)(lockPath);
-      return () => (0, import_node_fs14.rmSync)(lockPath, { recursive: true, force: true });
+      (0, import_node_fs13.mkdirSync)(lockPath);
+      return () => (0, import_node_fs13.rmSync)(lockPath, { recursive: true, force: true });
     } catch (error61) {
       const code = error61 && typeof error61 === "object" && "code" in error61 ? error61.code : void 0;
       if (code !== "EEXIST") throw error61;
       try {
-        if (Date.now() - (0, import_node_fs14.statSync)(lockPath).mtimeMs > CONFIG_LOCK_STALE_MS) {
-          (0, import_node_fs14.rmSync)(lockPath, { recursive: true, force: true });
+        if (Date.now() - (0, import_node_fs13.statSync)(lockPath).mtimeMs > CONFIG_LOCK_STALE_MS) {
+          (0, import_node_fs13.rmSync)(lockPath, { recursive: true, force: true });
           continue;
         }
       } catch {
@@ -55424,29 +55363,29 @@ function parseJsonObject2(path2, content) {
   }
   const hash2 = (0, import_node_crypto7.createHash)("sha256").update(content).digest("hex").slice(0, 12);
   const backupPath = `${path2}.alan-backup-${hash2}`;
-  if (!(0, import_node_fs14.existsSync)(backupPath)) (0, import_node_fs14.copyFileSync)(path2, backupPath);
+  if (!(0, import_node_fs13.existsSync)(backupPath)) (0, import_node_fs13.copyFileSync)(path2, backupPath);
   throw new Error(
     `Existing config is malformed; no changes were applied. Review the backup at ${backupPath}`
   );
 }
 async function configureAntigravityApiKeyMode(home = (0, import_node_os9.homedir)()) {
-  const path2 = (0, import_node_path15.join)(home, ".gemini", "antigravity-cli", "settings.json");
+  const path2 = (0, import_node_path14.join)(home, ".gemini", "antigravity-cli", "settings.json");
   const releaseLock = await waitForConfigLock(`${path2}.alan-lock`);
   try {
-    const existing = (0, import_node_fs14.existsSync)(path2) ? (0, import_node_fs14.readFileSync)(path2, "utf8") : "";
+    const existing = (0, import_node_fs13.existsSync)(path2) ? (0, import_node_fs13.readFileSync)(path2, "utf8") : "";
     const settings = existing.trim() ? parseJsonObject2(path2, existing) : {};
     if (settings.modelProvider === "gemini") return false;
     settings.modelProvider = "gemini";
     const pending = `${path2}.alan-pending-${process.pid}-${(0, import_node_crypto7.randomBytes)(6).toString("hex")}`;
     try {
-      (0, import_node_fs14.writeFileSync)(pending, JSON.stringify(settings), {
+      (0, import_node_fs13.writeFileSync)(pending, JSON.stringify(settings), {
         encoding: "utf8",
         mode: 384,
         flag: "wx"
       });
-      (0, import_node_fs14.renameSync)(pending, path2);
+      (0, import_node_fs13.renameSync)(pending, path2);
     } finally {
-      (0, import_node_fs14.rmSync)(pending, { force: true });
+      (0, import_node_fs13.rmSync)(pending, { force: true });
     }
     return true;
   } finally {
@@ -56286,6 +56225,75 @@ ${input2.userRequest}
 </user-request>` : instruction;
 }
 
+// src/workspace-relocation.ts
+var import_node_child_process8 = require("child_process");
+var import_node_fs14 = require("fs");
+var import_node_path15 = require("path");
+var MAX_RELOCATION_CANDIDATES = 200;
+var DEFAULT_PROBE2 = {
+  childDirectories: (parentPath, limit) => (0, import_node_fs14.readdirSync)(parentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).slice(0, limit).map((entry) => (0, import_node_path15.join)(parentPath, entry.name)),
+  gitRemoteUrl: (candidatePath) => {
+    const result = (0, import_node_child_process8.spawnSync)("git", ["-C", candidatePath, "config", "--get", "remote.origin.url"], {
+      encoding: "utf8",
+      env: getDaemonCliEnvironment(),
+      timeout: 2e3
+    });
+    if (result.status !== 0) return null;
+    const url3 = result.stdout.trim();
+    return url3 || null;
+  }
+};
+function normalizeRepositoryIdentity(value2) {
+  const trimmed = value2.trim().replace(/\/+$/, "").replace(/\.git$/i, "");
+  if (!trimmed) return null;
+  const scp = trimmed.match(/^(?:[^@/]+@)?([^:/]+):(.+)$/);
+  if (scp && !trimmed.includes("://")) {
+    return `${scp[1]}/${scp[2]}`.toLowerCase();
+  }
+  try {
+    const url3 = new URL(trimmed);
+    return `${url3.hostname}${url3.pathname}`.replace(/\/+$/, "").toLowerCase();
+  } catch {
+    return null;
+  }
+}
+function workspaceMatchesExpectedRepositories(input2) {
+  const identities = new Set(
+    input2.expectedRepoUrls.map(normalizeRepositoryIdentity).filter((identity3) => Boolean(identity3))
+  );
+  if (identities.size === 0) return false;
+  const remote = (input2.probe ?? DEFAULT_PROBE2).gitRemoteUrl((0, import_node_path15.resolve)(input2.workspacePath));
+  const identity2 = remote ? normalizeRepositoryIdentity(remote) : null;
+  return Boolean(identity2 && identities.has(identity2));
+}
+function discoverRelocatedWorkspace(input2) {
+  const identities = new Set(
+    input2.expectedRepoUrls.map(normalizeRepositoryIdentity).filter((identity2) => Boolean(identity2))
+  );
+  if (identities.size === 0) return null;
+  const searchRoots = [
+    (0, import_node_path15.dirname)((0, import_node_path15.resolve)(input2.missingPath)),
+    ...(input2.approvedWorkspacePaths ?? []).map((path2) => (0, import_node_path15.dirname)((0, import_node_path15.resolve)(path2)))
+  ].filter((path2, index, paths) => paths.indexOf(path2) === index);
+  const candidates = [];
+  for (const root of searchRoots) {
+    const remaining = MAX_RELOCATION_CANDIDATES - candidates.length;
+    if (remaining <= 0) break;
+    try {
+      candidates.push(...(input2.probe ?? DEFAULT_PROBE2).childDirectories(root, remaining));
+    } catch {
+    }
+  }
+  const matches = [];
+  for (const candidate of new Set(candidates.map((path2) => (0, import_node_path15.resolve)(path2)))) {
+    const remote = (input2.probe ?? DEFAULT_PROBE2).gitRemoteUrl(candidate);
+    const identity2 = remote ? normalizeRepositoryIdentity(remote) : null;
+    if (identity2 && identities.has(identity2)) matches.push((0, import_node_path15.resolve)(candidate));
+    if (matches.length > 1) return null;
+  }
+  return matches[0] ?? null;
+}
+
 // src/daemon-execute.ts
 async function handleAgentExecute(ctx, payload) {
   const {
@@ -64888,6 +64896,9 @@ var McpSyncService = class {
   cleanup(previousServers = []) {
     removeMcpFromAllClis(previousServers);
   }
+  uninstall(apiUrl) {
+    this.cleanup(toManagedMcpServers(buildAlanMcpServers(apiUrl)));
+  }
 };
 
 // src/native-hook-config.ts
@@ -66548,7 +66559,9 @@ async function runInstallCommand(commandArgs, currentPlatform = process.platform
     if (configurationMode === "login") await loginWithDeviceCode(commandArgs);
     await installDaemonService(commandArgs);
   }
-  runMcpIntegrationCommand(["reconcile", ...commandArgs]);
+  if (commandArgs.includes("--with-integrations")) {
+    runMcpIntegrationCommand(["reconcile", ...commandArgs]);
+  }
 }
 
 // src/lifecycle-logger.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alan-ai-hq/agent-manager",
-  "version": "0.1.111",
+  "version": "0.1.113",
   "type": "module",
   "description": "Alan agent runtime — cloud sandbox and local daemon (alan-agent CLI)",
   "bin": {