@serviceme/devtools-core 0.3.1 → 0.3.3

package/dist/index.mjs

@@ -454,6 +454,50 @@ var AccessControl = class {
   }
 };
 
+// src/logger.ts
+var noopLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+function formatArgs(args) {
+  return args.map((arg) => {
+    if (typeof arg === "string") {
+      return arg;
+    }
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }).join(" ");
+}
+function createConsoleLogger(prefix = "serviceme") {
+  return {
+    debug(message, ...args) {
+      process.stderr.write(`[${prefix}] DEBUG ${message} ${formatArgs(args)}
+`);
+    },
+    info(message, ...args) {
+      process.stderr.write(`[${prefix}] INFO ${message} ${formatArgs(args)}
+`);
+    },
+    warn(message, ...args) {
+      process.stderr.write(`[${prefix}] WARN ${message} ${formatArgs(args)}
+`);
+    },
+    error(message, ...args) {
+      process.stderr.write(`[${prefix}] ERROR ${message} ${formatArgs(args)}
+`);
+    }
+  };
+}
+
 // src/auth/AuthStateManager.ts
 import { EventEmitter } from "events";
 var AuthStateManager = class {
@@ -616,6 +660,7 @@ var AuthCore = class {
     this.state = opts.stateManager ?? new AuthStateManager();
     this.tokenStore = opts.tokenStore;
     this.accessControl = opts.accessControl;
+    this.logger = opts.logger ?? noopLogger;
   }
   /** Snapshot of every account, the active provider, and the last error. */
   status() {
@@ -637,16 +682,28 @@ var AuthCore = class {
    */
   async login(provider, ui, shouldContinue) {
     const providerImpl = this.registry.get(provider);
+    this.logger.info("[AuthCore] Starting device-flow login", { provider });
     try {
       const initial = await providerImpl.requestDeviceFlow();
       await ui(initial);
+      if (!initial.deviceCode) {
+        this.logger.error("[AuthCore] Provider did not return deviceCode", provider);
+        throw new Error("Auth provider did not return deviceCode for device flow completion");
+      }
       const session = await providerImpl.completeDeviceFlow(
-        initial.userCode ? initial.deviceCode ?? "" : "",
-        shouldContinue
+        initial.deviceCode,
+        shouldContinue,
+        initial.pollIntervalMs
       );
-      return await this.persistSession(providerImpl, session);
+      const result = await this.persistSession(providerImpl, session);
+      this.logger.info("[AuthCore] Device-flow login completed", { provider });
+      return result;
     } catch (err) {
-      this.state.recordError(err instanceof Error ? err.message : String(err));
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.error("[AuthCore] Device-flow login failed", message, {
+        provider
+      });
+      this.state.recordError(message);
       throw err;
     }
   }
@@ -671,7 +728,10 @@ var AuthCore = class {
     if (!provider) return null;
     const account = this.state.getActiveAccount();
     if (!account) return null;
-    const envelope = await this.tokenStore.get({ provider, accountId: account.id });
+    const envelope = await this.tokenStore.get({
+      provider,
+      accountId: account.id
+    });
     if (!envelope) return null;
     return { provider, account, token: envelope.token };
   }
@@ -681,9 +741,15 @@ var AuthCore = class {
    * every account.
    */
   async logout(provider) {
+    this.logger.info("[AuthCore] Logout requested", {
+      provider: provider ?? "all"
+    });
     if (!provider) {
       for (const account of this.state.listAccounts()) {
-        await this.tokenStore.delete({ provider: account.provider, accountId: account.id });
+        await this.tokenStore.delete({
+          provider: account.provider,
+          accountId: account.id
+        });
         this.state.removeAccount(account.provider, account.id);
       }
       this.state.clearAll();
@@ -758,6 +824,10 @@ var AuthCore = class {
       avatarUrl: meta.avatarUrl,
       expiresAt: meta.expiresAt ?? expiresAt
     };
+    this.logger.debug("[AuthCore] Persisting session", {
+      provider: meta.provider,
+      accountId: meta.id
+    });
     await this.tokenStore.set({ provider: meta.provider, accountId: meta.id }, session.token, {
       expiresAt
     });
@@ -860,11 +930,13 @@ var GitHubAuthProvider = class {
       userUrl: config.userUrl ?? DEFAULT_USER_URL,
       scope: config.scope ?? DEFAULT_SCOPE,
       minPollIntervalMs: config.minPollIntervalMs ?? 1e3,
-      maxPollIntervalMs: config.maxPollIntervalMs ?? 15e3,
+      maxPollIntervalMs: config.maxPollIntervalMs ?? 6e4,
       maxWaitMs: config.maxWaitMs,
       fetchImpl: config.fetchImpl ?? fetch,
       deviceCodeRetryBaseDelayMs: config.deviceCodeRetryBaseDelayMs ?? DEFAULT_DEVICE_CODE_RETRY_BASE_DELAY_MS
     };
+    this.logger = config.logger ?? noopLogger;
+    this.sleepImpl = config.sleepImpl ?? sleep;
   }
   async requestDeviceFlow(opts) {
     const body = JSON.stringify({
@@ -873,6 +945,10 @@ var GitHubAuthProvider = class {
     });
     let lastNetworkError;
     for (let attempt = 1; attempt <= DEVICE_CODE_MAX_ATTEMPTS; attempt++) {
+      this.logger.debug("[GitHubAuthProvider] Requesting device code", {
+        attempt,
+        maxAttempts: DEVICE_CODE_MAX_ATTEMPTS
+      });
       let resp;
       try {
         resp = await this.cfg.fetchImpl(this.cfg.deviceCodeUrl, {
@@ -886,45 +962,99 @@ var GitHubAuthProvider = class {
         });
       } catch (error) {
         if (!isTransientNetworkError(error) || attempt === DEVICE_CODE_MAX_ATTEMPTS) {
+          this.logger.error(
+            "[GitHubAuthProvider] Device-code request failed (non-retryable)",
+            error instanceof Error ? error.message : String(error),
+            { attempt }
+          );
           throw error;
         }
+        const delayMs = this.cfg.deviceCodeRetryBaseDelayMs * 2 ** (attempt - 1);
+        this.logger.warn(
+          "[GitHubAuthProvider] Transient network error requesting device code, retrying",
+          {
+            attempt,
+            delayMs,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
         lastNetworkError = error;
-        await sleep(this.cfg.deviceCodeRetryBaseDelayMs * 2 ** (attempt - 1));
+        await this.sleepImpl(delayMs);
         continue;
       }
       if (!resp.ok) {
+        this.logger.error(
+          "[GitHubAuthProvider] Device-code request rejected by GitHub",
+          `HTTP ${resp.status}`
+        );
         throw new Error(`GitHub device-code request failed: HTTP ${resp.status}`);
       }
       const data = await resp.json();
       if (!data.device_code || !data.user_code || !data.verification_uri) {
+        this.logger.error(
+          "[GitHubAuthProvider] Device-code response missing required fields",
+          JSON.stringify(Object.keys(data))
+        );
         throw new Error("GitHub device-code response missing required fields");
       }
+      this.logger.info("[GitHubAuthProvider] Device code obtained", {
+        userCode: data.user_code,
+        verificationUri: data.verification_uri,
+        expiresInSec: data.expires_in,
+        pollIntervalSec: data.interval
+      });
       return {
         provider: this.providerId,
+        deviceCode: data.device_code,
         userCode: data.user_code,
         verificationUrl: data.verification_uri,
         expiresAt: Date.now() + data.expires_in * 1e3,
+        pollIntervalMs: data.interval * 1e3,
         message: `Open ${data.verification_uri} and enter ${data.user_code}`
       };
     }
     throw lastNetworkError ?? new Error("GitHub device-code request failed");
   }
-  async completeDeviceFlow(deviceCode, shouldContinue) {
+  async completeDeviceFlow(deviceCode, shouldContinue, initialPollIntervalMs) {
     const start = Date.now();
-    let pollIntervalMs = this.cfg.minPollIntervalMs;
+    let pollIntervalMs = Math.max(this.cfg.minPollIntervalMs, initialPollIntervalMs ?? 0);
     let consecutiveSlowDown = 0;
+    let pollCount = 0;
+    this.logger.info("[GitHubAuthProvider] Starting device-flow polling", {
+      initialPollIntervalMs: pollIntervalMs,
+      maxWaitMs: this.cfg.maxWaitMs
+    });
     while (true) {
       if (shouldContinue && !shouldContinue()) {
+        this.logger.info("[GitHubAuthProvider] Device flow cancelled by caller", {
+          elapsedMs: Date.now() - start,
+          pollCount
+        });
         throw new Error("GitHub device flow cancelled by caller");
       }
       const elapsed = Date.now() - start;
       if (this.cfg.maxWaitMs !== void 0 && elapsed > this.cfg.maxWaitMs) {
+        this.logger.warn("[GitHubAuthProvider] Device flow exceeded max wait time", {
+          elapsedMs: elapsed,
+          maxWaitMs: this.cfg.maxWaitMs,
+          pollCount
+        });
         throw new Error("GitHub device flow exceeded max wait time");
       }
-      await sleep(pollIntervalMs);
+      await this.sleepImpl(pollIntervalMs);
       if (shouldContinue && !shouldContinue()) {
+        this.logger.info("[GitHubAuthProvider] Device flow cancelled by caller", {
+          elapsedMs: Date.now() - start,
+          pollCount
+        });
         throw new Error("GitHub device flow cancelled by caller");
       }
+      pollCount++;
+      this.logger.debug("[GitHubAuthProvider] Polling for authorization", {
+        pollCount,
+        elapsedMs: Date.now() - start,
+        pollIntervalMs
+      });
       let resp;
       try {
         resp = await this.cfg.fetchImpl(this.cfg.tokenUrl, {
@@ -942,19 +1072,59 @@ var GitHubAuthProvider = class {
         });
       } catch (error) {
         if (!isTransientNetworkError(error)) {
+          this.logger.error(
+            "[GitHubAuthProvider] Non-retryable error while polling token endpoint",
+            error instanceof Error ? error.message : String(error),
+            { pollCount }
+          );
           throw error;
         }
-        pollIntervalMs = Math.min(Math.round(pollIntervalMs * 1.5), this.cfg.maxPollIntervalMs);
+        const nextPollIntervalMs = Math.min(
+          Math.round(pollIntervalMs * 1.5),
+          this.cfg.maxPollIntervalMs
+        );
+        this.logger.warn(
+          "[GitHubAuthProvider] Transient network error while polling, backing off",
+          {
+            pollCount,
+            error: error instanceof Error ? error.message : String(error),
+            previousPollIntervalMs: pollIntervalMs,
+            nextPollIntervalMs
+          }
+        );
+        pollIntervalMs = nextPollIntervalMs;
         continue;
       }
       if (!resp.ok) {
-        pollIntervalMs = Math.min(Math.round(pollIntervalMs * 1.5), this.cfg.maxPollIntervalMs);
+        const nextPollIntervalMs = Math.min(
+          Math.round(pollIntervalMs * 1.5),
+          this.cfg.maxPollIntervalMs
+        );
+        this.logger.warn(
+          "[GitHubAuthProvider] Token endpoint returned non-OK status, backing off",
+          {
+            pollCount,
+            status: resp.status,
+            previousPollIntervalMs: pollIntervalMs,
+            nextPollIntervalMs
+          }
+        );
+        pollIntervalMs = nextPollIntervalMs;
         continue;
       }
       const data = await resp.json();
       if (data.access_token) {
+        this.logger.info("[GitHubAuthProvider] Authorization granted, fetching user profile", {
+          pollCount,
+          elapsedMs: Date.now() - start
+        });
         const rawUser = await this.fetchGitHubUser(data.access_token);
         const email = await this.resolveEmail(data.access_token, rawUser);
+        this.logger.info("[GitHubAuthProvider] Device-flow login completed", {
+          pollCount,
+          elapsedMs: Date.now() - start,
+          login: rawUser.login
+        });
         return {
           token: data.access_token,
           refreshToken: data.refresh_token,
@@ -969,22 +1139,42 @@ var GitHubAuthProvider = class {
         };
       }
       if (data.error === "authorization_pending") {
+        this.logger.debug("[GitHubAuthProvider] Authorization still pending", {
+          pollCount,
+          elapsedMs: Date.now() - start
+        });
         continue;
       }
       if (data.error === "slow_down") {
         consecutiveSlowDown++;
-        pollIntervalMs = Math.min(
-          Math.round(pollIntervalMs * 1.5 + Math.min(consecutiveSlowDown * 500, 2e3)),
-          this.cfg.maxPollIntervalMs
-        );
+        const nextPollIntervalMs = Math.min(pollIntervalMs + 5e3, this.cfg.maxPollIntervalMs);
+        this.logger.warn("[GitHubAuthProvider] GitHub requested slower polling (slow_down)", {
+          pollCount,
+          consecutiveSlowDown,
+          previousPollIntervalMs: pollIntervalMs,
+          nextPollIntervalMs
+        });
+        pollIntervalMs = nextPollIntervalMs;
         continue;
       }
       if (data.error === "access_denied") {
+        this.logger.warn("[GitHubAuthProvider] User denied authorization", {
+          pollCount
+        });
         throw new Error("User denied authorization");
       }
       if (data.error === "expired_token") {
+        this.logger.warn(
+          "[GitHubAuthProvider] Device code expired before authorization completed",
+          { pollCount, elapsedMs: Date.now() - start }
+        );
         throw new Error("GitHub device code expired \u2014 restart the flow");
       }
+      this.logger.error(
+        "[GitHubAuthProvider] Unexpected device-flow error from token endpoint",
+        data.error ?? "unknown",
+        { pollCount }
+      );
       throw new Error(`GitHub device flow error: ${data.error ?? "unknown"}`);
     }
   }
@@ -1671,6 +1861,7 @@ var DRAFTS_SUBDIR = "drafts";
 var SKILL_DRAFTS_SUBDIR = "skills";
 var AGENT_DRAFTS_SUBDIR = "agents";
 var REPOS_CONFIG_FILENAME = "repos.json";
+var SERVER_PROXY_GLOBAL_FILENAME = "server-proxy.json";
 var SAFE_REPO_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
 var SERVICEME_HOME_ENV = "SERVICEME_HOME";
 var activeOverrides = {};
@@ -1771,6 +1962,9 @@ function getMigrationFailuresPath() {
 function getKnownWorkspacesPath() {
   return path2.join(getServicemeHome(), KNOWN_WORKSPACES_FILENAME);
 }
+function getServerProxyGlobalPath() {
+  return path2.join(getServicemeHome(), SERVER_PROXY_GLOBAL_FILENAME);
+}
 var CREDENTIALS_CONFIG_FILENAME = "credentials.json";
 var DEVICE_JSON_FILENAME = "device.json";
 var TOOLBOX_JSON_FILENAME = "toolbox.json";
@@ -1862,10 +2056,20 @@ function isRecord(value) {
 function isNodeError(value) {
   return value instanceof Error && typeof value.code === "string";
 }
+var LOCK_PID_FILE = "pid";
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 var FileLock = class {
   constructor(filePath, timeoutMs, retryMs) {
     this.acquired = false;
     this.dirPath = `${filePath}.lock`;
+    this.pidFilePath = path3.join(this.dirPath, LOCK_PID_FILE);
     this.timeoutMs = timeoutMs;
     this.retryMs = retryMs;
   }
@@ -1874,12 +2078,18 @@ var FileLock = class {
     while (true) {
       try {
         await fsp.mkdir(this.dirPath, { mode: LOCK_DIR_MODE });
+        await fsp.writeFile(this.pidFilePath, String(process.pid), "utf8").catch(() => void 0);
         this.acquired = true;
         return;
       } catch (err) {
         if (!isNodeError(err) || err.code !== "EEXIST") {
           throw err;
         }
+        const stale = await this.isStaleLock();
+        if (stale) {
+          await fsp.rm(this.dirPath, { recursive: true, force: true });
+          continue;
+        }
         if (Date.now() - start >= this.timeoutMs) {
           throw new Error(`IdentityStore lock acquisition timed out for ${this.dirPath}`);
         }
@@ -1887,6 +2097,16 @@ var FileLock = class {
       }
     }
   }
+  async isStaleLock() {
+    try {
+      const pidStr = await fsp.readFile(this.pidFilePath, "utf8");
+      const pid = Number.parseInt(pidStr.trim(), 10);
+      if (!Number.isFinite(pid) || pid <= 0) return true;
+      return !isProcessAlive(pid);
+    } catch {
+      return true;
+    }
+  }
   async release() {
     if (!this.acquired) return;
     this.acquired = false;
@@ -2315,6 +2535,14 @@ var TOOL_CHECK_TIMEOUT_MS = {
   pnpm: 15e3,
   nrm: 15e3
 };
+var POSIX_LOGIN_SHELL_FALLBACK_TOOLS = /* @__PURE__ */ new Set([
+  "npm",
+  "pnpm",
+  "nrm",
+  "node",
+  "dotnet",
+  "rtk"
+]);
 var ERROR_CODE_NOT_FOUND = 127;
 var ERROR_CODE_TIMEOUT = "ETIMEDOUT";
 var EnvironmentInspector = class {
@@ -2358,6 +2586,23 @@ var EnvironmentInspector = class {
         timeoutMs: this.getToolTimeout(toolName)
       });
       return result.stdout.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
+    } catch {
+      if (this.shouldUsePosixLoginShellFallback(toolName)) {
+        return this.getToolPathFromLoginShell(toolName);
+      }
+      return void 0;
+    }
+  }
+  async getToolPathFromLoginShell(toolName) {
+    try {
+      const result = await this.runCommandFn("/bin/bash", {
+        args: [
+          "-lc",
+          'export NVM_DIR="$HOME/.nvm"; [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; command -v ' + toolName
+        ],
+        timeoutMs: this.getToolTimeout(toolName)
+      });
+      return result.stdout.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
     } catch {
       return void 0;
     }
@@ -2382,12 +2627,33 @@ var EnvironmentInspector = class {
     }
   }
   async getToolVersion(toolName) {
-    const invocation = await this.getVersionInvocation(toolName);
-    const result = await this.runCommandFn(invocation.command, {
-      args: invocation.args,
-      timeoutMs: this.getToolTimeout(toolName)
-    });
-    return this.parseVersion(toolName, result.stdout || result.stderr);
+    try {
+      const invocation = await this.getVersionInvocation(toolName);
+      const result = await this.runCommandFn(invocation.command, {
+        args: invocation.args,
+        timeoutMs: this.getToolTimeout(toolName)
+      });
+      return this.parseVersion(toolName, result.stdout || result.stderr);
+    } catch (error) {
+      if (!this.shouldUsePosixLoginShellFallback(toolName)) {
+        throw error;
+      }
+      const fallbackResult = await this.runCommandFn("/bin/bash", {
+        args: [
+          "-lc",
+          `export NVM_DIR="$HOME/.nvm"; [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; ${toolName} --version`
+        ],
+        timeoutMs: this.getToolTimeout(toolName)
+      });
+      const fallbackOutput = (fallbackResult.stdout || fallbackResult.stderr).trim();
+      if (!fallbackOutput) {
+        throw error;
+      }
+      return this.parseVersion(toolName, fallbackOutput);
+    }
+  }
+  shouldUsePosixLoginShellFallback(toolName) {
+    return this.platform !== "win32" && POSIX_LOGIN_SHELL_FALLBACK_TOOLS.has(toolName);
   }
   async checkNvm() {
     if (this.platform === "win32") {
@@ -2437,7 +2703,7 @@ var EnvironmentInspector = class {
       };
     }
     try {
-      const result = await this.runCommandFn("dotnet", {
+      const result = await this.runCommandFn(dotnetPath, {
         args: ["nuget", "list", "source"],
         timeoutMs: this.getToolTimeout("nuget")
       });
@@ -2973,54 +3239,85 @@ function detectIndent(text) {
   return 2;
 }
 
-// src/logger.ts
-var noopLogger = {
-  debug() {
-  },
-  info() {
-  },
-  warn() {
-  },
-  error() {
-  }
-};
-function formatArgs(args) {
-  return args.map((arg) => {
-    if (typeof arg === "string") {
-      return arg;
-    }
-    try {
-      return JSON.stringify(arg);
-    } catch {
-      return String(arg);
-    }
-  }).join(" ");
-}
-function createConsoleLogger(prefix = "serviceme") {
-  return {
-    debug(message, ...args) {
-      process.stderr.write(`[${prefix}] DEBUG ${message} ${formatArgs(args)}
-`);
-    },
-    info(message, ...args) {
-      process.stderr.write(`[${prefix}] INFO ${message} ${formatArgs(args)}
-`);
-    },
-    warn(message, ...args) {
-      process.stderr.write(`[${prefix}] WARN ${message} ${formatArgs(args)}
-`);
-    },
-    error(message, ...args) {
-      process.stderr.write(`[${prefix}] ERROR ${message} ${formatArgs(args)}
-`);
+// src/paths/serverProxyGlobal.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import * as fs6 from "fs/promises";
+import { open as open2 } from "fs/promises";
+import * as path9 from "path";
+async function readServerProxyGlobal() {
+  const filePath = getServerProxyGlobalPath();
+  try {
+    const raw = await fs6.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isServerProxyGlobalState(parsed)) {
+      throw new Error(
+        `Invalid ${SERVER_PROXY_GLOBAL_FILENAME}: expected {enabled: boolean, lastServerUrl?: string, updatedAt: string}, got ${JSON.stringify(parsed).slice(0, 80)}`
+      );
     }
+    return parsed;
+  } catch (err) {
+    if (isENOENT(err)) return null;
+    throw err;
+  }
+}
+async function writeServerProxyGlobal(patch) {
+  const filePath = getServerProxyGlobalPath();
+  const dirPath = path9.dirname(filePath);
+  await fs6.mkdir(dirPath, { recursive: true });
+  const current = await readServerProxyGlobal() ?? {
+    enabled: false,
+    allowOverride: false,
+    lastServerUrl: void 0,
+    updatedAt: (/* @__PURE__ */ new Date(0)).toISOString()
   };
+  const next = {
+    enabled: patch.enabled !== void 0 ? patch.enabled : current.enabled,
+    allowOverride: patch.allowOverride !== void 0 ? patch.allowOverride : current.allowOverride,
+    lastServerUrl: patch.lastServerUrl === void 0 ? current.lastServerUrl : patch.lastServerUrl === null ? void 0 : patch.lastServerUrl,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const tmpPath = `${filePath}.tmp-${randomUUID2()}`;
+  const fh = await open2(tmpPath, "w");
+  try {
+    await fh.writeFile(JSON.stringify(next, null, "	"), "utf8");
+    await fh.sync();
+  } finally {
+    await fh.close();
+  }
+  await fs6.rename(tmpPath, filePath);
+  return next;
+}
+async function migrateLegacyServerProxyEnabled(readLegacy, clearLegacy) {
+  const legacyEnabled = readLegacy();
+  if (legacyEnabled !== true) return null;
+  const existing = await readServerProxyGlobal();
+  if (existing?.enabled === true) {
+    await clearLegacy();
+    return null;
+  }
+  const next = await writeServerProxyGlobal({ enabled: true });
+  await clearLegacy();
+  return next;
+}
+function isServerProxyGlobalState(v) {
+  if (!v || typeof v !== "object") return false;
+  const obj = v;
+  if (typeof obj.enabled !== "boolean") return false;
+  if (typeof obj.allowOverride !== "boolean") return false;
+  if (typeof obj.updatedAt !== "string") return false;
+  if (obj.lastServerUrl !== void 0 && obj.lastServerUrl !== null && typeof obj.lastServerUrl !== "string") {
+    return false;
+  }
+  return true;
+}
+function isENOENT(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 
 // src/phase5/bootstrap.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import * as fs6 from "fs/promises";
-import * as path9 from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+import * as fs7 from "fs/promises";
+import * as path10 from "path";
 function getPhase5FileSpecs() {
   return [
     {
@@ -3051,7 +3348,7 @@ function getPhase5FileSpecs() {
       path: getMachineIdPath(),
       // Random uuid, written as a bare string. Subsequent
       // activations see the file and skip re-randomizing.
-      defaultContent: randomUUID2()
+      defaultContent: randomUUID3()
     },
     {
       path: getProfilesJsonPath(),
@@ -3065,19 +3362,19 @@ async function bootstrapPhase5Placeholders() {
   const result = { created: [], skipped: [], failed: [] };
   const home = getServicemeHome();
   try {
-    await fs6.mkdir(home, { recursive: true });
+    await fs7.mkdir(home, { recursive: true });
   } catch (err) {
     result.failed.push({ path: home, reason: err.message });
     return result;
   }
   for (const spec of getPhase5FileSpecs()) {
     try {
-      await fs6.access(spec.path);
+      await fs7.access(spec.path);
       result.skipped.push(spec.path);
     } catch {
       try {
-        await fs6.mkdir(path9.dirname(spec.path), { recursive: true });
-        await fs6.writeFile(spec.path, spec.defaultContent, "utf8");
+        await fs7.mkdir(path10.dirname(spec.path), { recursive: true });
+        await fs7.writeFile(spec.path, spec.defaultContent, "utf8");
         result.created.push(spec.path);
       } catch (writeErr) {
         result.failed.push({ path: spec.path, reason: writeErr.message });
@@ -3088,16 +3385,16 @@ async function bootstrapPhase5Placeholders() {
 }
 
 // src/project/projectTools.ts
-import * as fs7 from "fs/promises";
-import * as path10 from "path";
+import * as fs8 from "fs/promises";
+import * as path11 from "path";
 import {
   createServicemeError as createServicemeError7
 } from "@serviceme/devtools-protocol";
 
 // src/utils/fileUtils.ts
 import { constants, createWriteStream } from "fs";
-import { access as access5, copyFile, lstat, mkdir as mkdir4, readdir as readdir3, rename as rename3, rm as rm3 } from "fs/promises";
-import { dirname as dirname6, join as join7 } from "path";
+import { access as access5, copyFile, lstat, mkdir as mkdir5, readdir as readdir3, rename as rename4, rm as rm3 } from "fs/promises";
+import { dirname as dirname7, join as join8 } from "path";
 import yauzl from "yauzl";
 var unzipFile = (zipPath, dest) => {
   return new Promise((resolve3, reject) => {
@@ -3107,12 +3404,12 @@ var unzipFile = (zipPath, dest) => {
       zipfile.readEntry();
       zipfile.on("entry", (entry) => {
         if (/\/$/.test(entry.fileName)) {
-          void mkdir4(join7(dest, entry.fileName), { recursive: true }).then(() => {
+          void mkdir5(join8(dest, entry.fileName), { recursive: true }).then(() => {
             zipfile.readEntry();
           }).catch(reject);
         } else {
-          const outputPath = join7(dest, entry.fileName);
-          void mkdir4(dirname6(outputPath), { recursive: true }).then(() => {
+          const outputPath = join8(dest, entry.fileName);
+          void mkdir5(dirname7(outputPath), { recursive: true }).then(() => {
             zipfile.openReadStream(
               entry,
               (streamError, readStream) => {
@@ -3157,10 +3454,10 @@ var mergeEntry = async (sourcePath, destPath, overwrite) => {
       }
       await rm3(destPath, { recursive: true, force: true });
     }
-    await mkdir4(destPath, { recursive: true });
+    await mkdir5(destPath, { recursive: true });
     const children = await readdir3(sourcePath);
     for (const child of children) {
-      await mergeEntry(join7(sourcePath, child), join7(destPath, child), overwrite);
+      await mergeEntry(join8(sourcePath, child), join8(destPath, child), overwrite);
     }
     await rm3(sourcePath, { recursive: true, force: true });
     return;
@@ -3173,18 +3470,18 @@ var mergeEntry = async (sourcePath, destPath, overwrite) => {
     await rm3(destPath, { recursive: true, force: true });
   }
   try {
-    await rename3(sourcePath, destPath);
+    await rename4(sourcePath, destPath);
   } catch {
     await copyFile(sourcePath, destPath);
     await rm3(sourcePath, { recursive: true, force: true });
   }
 };
 var moveFiles = async (sourceDir, destDir, overwrite = false) => {
-  await mkdir4(destDir, { recursive: true });
+  await mkdir5(destDir, { recursive: true });
   const files = await readdir3(sourceDir);
   for (const file of files) {
-    const sourceFile = join7(sourceDir, file);
-    const destFile = join7(destDir, file);
+    const sourceFile = join8(sourceDir, file);
+    const destFile = join8(destDir, file);
     if (!overwrite) {
       try {
         await access5(destFile, constants.F_OK);
@@ -3201,10 +3498,10 @@ var moveFiles = async (sourceDir, destDir, overwrite = false) => {
 var ProjectTools = class {
   async extractTemplate(zipPath, workspacePath, tempExtractDir, input) {
     await unzipFile(zipPath, tempExtractDir);
-    let sourceDir = path10.join(tempExtractDir, input.extractedDirName);
+    let sourceDir = path11.join(tempExtractDir, input.extractedDirName);
     let actualDirName = input.extractedDirName;
     if (!await this.pathExists(sourceDir)) {
-      const entries = await fs7.readdir(tempExtractDir, { withFileTypes: true });
+      const entries = await fs8.readdir(tempExtractDir, { withFileTypes: true });
       const directories = entries.filter(
         (entry) => entry.isDirectory() && !entry.name.startsWith(".")
       );
@@ -3216,7 +3513,7 @@ var ProjectTools = class {
       );
       if (selectedDirectory) {
         actualDirName = selectedDirectory;
-        sourceDir = path10.join(tempExtractDir, actualDirName);
+        sourceDir = path11.join(tempExtractDir, actualDirName);
       } else if (directories.length === 0) {
         throw new Error(
           `No directory found after extraction. Expected directory: ${input.extractedDirName}`
@@ -3266,7 +3563,7 @@ var ProjectTools = class {
     } else {
       for (const scriptPath of scripts) {
         try {
-          await fs7.chmod(scriptPath, 493);
+          await fs8.chmod(scriptPath, 493);
           updatedCount += 1;
         } catch {
         }
@@ -3314,7 +3611,7 @@ var ProjectTools = class {
     };
   }
   async ensurePresetManifest(workspacePath, preset) {
-    const presetManifestPath = path10.join(
+    const presetManifestPath = path11.join(
       workspacePath,
       ".ms-scaffold",
       "presets",
@@ -3323,11 +3620,11 @@ var ProjectTools = class {
     if (await this.pathExists(presetManifestPath)) {
       return;
     }
-    const projectModePath = path10.join(workspacePath, ".ms-scaffold", "project-mode.json");
+    const projectModePath = path11.join(workspacePath, ".ms-scaffold", "project-mode.json");
     if (!await this.pathExists(projectModePath)) {
       return;
     }
-    const projectModeRaw = await fs7.readFile(projectModePath, "utf8");
+    const projectModeRaw = await fs8.readFile(projectModePath, "utf8");
     const projectMode = JSON.parse(projectModeRaw);
     const synthesizedPreset = {
       preset,
@@ -3339,8 +3636,8 @@ var ProjectTools = class {
       mergeManagedFiles: [],
       userOwnedPaths: []
     };
-    await fs7.mkdir(path10.dirname(presetManifestPath), { recursive: true });
-    await fs7.writeFile(
+    await fs8.mkdir(path11.dirname(presetManifestPath), { recursive: true });
+    await fs8.writeFile(
       presetManifestPath,
       `${JSON.stringify(synthesizedPreset, null, 2)}
 `,
@@ -3351,12 +3648,12 @@ var ProjectTools = class {
     const results = [];
     let entries;
     try {
-      entries = await fs7.readdir(dir, { withFileTypes: true });
+      entries = await fs8.readdir(dir, { withFileTypes: true });
     } catch {
       return results;
     }
     for (const entry of entries) {
-      const fullPath = path10.join(dir, entry.name);
+      const fullPath = path11.join(dir, entry.name);
       if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
         results.push(...await this.findScripts(fullPath, extensions));
       } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
@@ -3367,7 +3664,7 @@ var ProjectTools = class {
   }
   async pathExists(targetPath) {
     try {
-      await fs7.access(targetPath);
+      await fs8.access(targetPath);
       return true;
     } catch {
       return false;
@@ -3384,7 +3681,7 @@ var ProjectTools = class {
     const matches = [];
     for (const directoryName of directoryNames) {
       if (await this.directoryMatchesProjectPattern(
-        path10.join(tempExtractDir, directoryName),
+        path11.join(tempExtractDir, directoryName),
         projectFilePattern
       )) {
         matches.push(directoryName);
@@ -3396,7 +3693,7 @@ var ProjectTools = class {
     return null;
   }
   async directoryMatchesProjectPattern(directoryPath, projectFilePattern) {
-    const entries = await fs7.readdir(directoryPath);
+    const entries = await fs8.readdir(directoryPath);
     if (projectFilePattern.includes("*")) {
       const regex = new RegExp(`^${projectFilePattern.replace("*", ".*")}$`);
       return entries.some((entry) => regex.test(entry));
@@ -3409,8 +3706,8 @@ function createProjectTools() {
 }
 
 // src/repo-manager/index.ts
-import * as fs8 from "fs/promises";
-import * as path11 from "path";
+import * as fs9 from "fs/promises";
+import * as path12 from "path";
 
 // src/repos/types.ts
 function isDefaultRepo(repo) {
@@ -3492,11 +3789,11 @@ var RepoManager = class {
       const exists = await this.pathExists(localPath);
       if (exists) {
         if (await this.isValidGitRepo(localPath)) continue;
-        await fs8.rm(localPath, { recursive: true, force: true });
+        await fs9.rm(localPath, { recursive: true, force: true });
       }
       try {
         if (!this.skipClone) {
-          await fs8.mkdir(path11.dirname(localPath), { recursive: true });
+          await fs9.mkdir(path12.dirname(localPath), { recursive: true });
           await this.git.clone(repo.id, repo.url, localPath, repo.branch, true);
         }
         await this.store.updateRepo(repo.id, {
@@ -3531,10 +3828,10 @@ var RepoManager = class {
     const localPath = getRepoDir(repoId);
     const exists = await this.pathExists(localPath);
     if (exists && !await this.isValidGitRepo(localPath)) {
-      await fs8.rm(localPath, { recursive: true, force: true });
+      await fs9.rm(localPath, { recursive: true, force: true });
     }
     if (!exists || !await this.pathExists(localPath)) {
-      await fs8.mkdir(path11.dirname(localPath), { recursive: true });
+      await fs9.mkdir(path12.dirname(localPath), { recursive: true });
       if (!this.skipClone) {
         await this.git.clone(proxyId, repo.url, localPath, repo.branch, useProxy);
       }
@@ -3634,7 +3931,7 @@ var RepoManager = class {
     let cloned = false;
     if (!this.skipClone) {
       const localPath = getRepoDir(id);
-      await fs8.mkdir(path11.dirname(localPath), { recursive: true });
+      await fs9.mkdir(path12.dirname(localPath), { recursive: true });
       await this.git.clone(userProxyId, url, localPath, branch, useProxy);
       cloned = true;
     }
@@ -3659,7 +3956,7 @@ var RepoManager = class {
     await this.store.removeUserRepo(repoId);
     const localPath = getRepoDir(repoId);
     try {
-      await fs8.rm(localPath, { recursive: true, force: true });
+      await fs9.rm(localPath, { recursive: true, force: true });
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
@@ -3682,7 +3979,7 @@ var RepoManager = class {
   }
   /** Force-create the SERVICEME home directory tree (idempotent). */
   async ensureHome() {
-    await fs8.mkdir(getServicemeHome(), { recursive: true });
+    await fs9.mkdir(getServicemeHome(), { recursive: true });
   }
   /**
    * Returns `true` when `p` contains a `.git` entry — i.e. it is an
@@ -3690,11 +3987,11 @@ var RepoManager = class {
    * (e.g. from an interrupted clone) return `false`.
    */
   async isValidGitRepo(p) {
-    return this.pathExists(path11.join(p, ".git"));
+    return this.pathExists(path12.join(p, ".git"));
   }
   async pathExists(p) {
     try {
-      await fs8.stat(p);
+      await fs9.stat(p);
       return true;
     } catch {
       return false;
@@ -3819,8 +4116,8 @@ function resolveDefaultRepoId(existing, existingIds) {
 }
 
 // src/repos/loader.ts
-import * as fs9 from "fs/promises";
-import * as path12 from "path";
+import * as fs10 from "fs/promises";
+import * as path13 from "path";
 import { z } from "zod";
 var ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
 var repoIdSchema = z.string().min(1).max(64).regex(SAFE_REPO_ID_PATTERN, "repo id must match /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/");
@@ -3903,7 +4200,7 @@ var ReposLoader = class {
     this.configPath = options.configPath;
     this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
     this.randomSuffix = options.randomSuffix ?? defaultRandomSuffix;
-    this.fileSystem = options.fileSystem ?? fs9;
+    this.fileSystem = options.fileSystem ?? fs10;
   }
   /** Absolute path of the file this loader reads/writes. */
   getConfigPath() {
@@ -3956,7 +4253,7 @@ var ReposLoader = class {
    */
   async save(config) {
     const validated = reposFileSchema.parse(config);
-    const dir = path12.dirname(this.configPath);
+    const dir = path13.dirname(this.configPath);
     await this.fileSystem.mkdir(dir, { recursive: true });
     const serialized = `${JSON.stringify(validated, null, 2)}
 `;
@@ -3965,7 +4262,7 @@ var ReposLoader = class {
     try {
       await this.fileSystem.rename(tempPath, this.configPath);
     } catch (error) {
-      const unlink2 = this.fileSystem.unlink ?? fs9.unlink;
+      const unlink2 = this.fileSystem.unlink ?? fs10.unlink;
       await unlink2(tempPath).catch(() => void 0);
       throw error;
     }
@@ -4025,7 +4322,7 @@ function narrowRepoConfig(repo) {
 
 // src/repos/store.ts
 import { EventEmitter as EventEmitter2 } from "events";
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 var ReposStore = class {
   constructor(options = {}) {
     this.config = null;
@@ -4034,7 +4331,7 @@ var ReposStore = class {
     this.reloadTimer = null;
     this.lastLoadResult = null;
     this.loader = options.loader ?? new ReposLoader({ configPath: "" });
-    this.fileSystem = options.fileSystem ?? { watch: fs10.watch };
+    this.fileSystem = options.fileSystem ?? { watch: fs11.watch };
     this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
     this.debounceMs = options.debounceMs ?? 50;
     this.createFsWatcher = options.createFsWatcher ?? ((p, cb) => this.defaultCreateFsWatcher(p, cb));
@@ -4316,17 +4613,17 @@ async function bootstrapDefaults(store) {
 }
 
 // src/scheduled-tasks/daemon/DaemonLogger.ts
-import * as fs11 from "fs";
-import * as path13 from "path";
+import * as fs12 from "fs";
+import * as path14 from "path";
 var CONFIG_DIR = ".serviceme";
 var LOG_FILE = "scheduler.log";
 var MAX_LOG_SIZE = 1024 * 1024;
 var DaemonLogger = class {
   constructor(workspacePath, options = {}) {
-    this.logPath = options.logPath ?? path13.join(workspacePath, CONFIG_DIR, LOG_FILE);
-    const dir = path13.dirname(this.logPath);
-    if (!fs11.existsSync(dir)) {
-      fs11.mkdirSync(dir, { recursive: true });
+    this.logPath = options.logPath ?? path14.join(workspacePath, CONFIG_DIR, LOG_FILE);
+    const dir = path14.dirname(this.logPath);
+    if (!fs12.existsSync(dir)) {
+      fs12.mkdirSync(dir, { recursive: true });
     }
   }
   getLogPath() {
@@ -4337,16 +4634,16 @@ var DaemonLogger = class {
     const line = `[${ts}] [${level.toUpperCase()}] ${message}
 `;
     this.rotateIfNeeded();
-    fs11.appendFileSync(this.logPath, line, "utf-8");
+    fs12.appendFileSync(this.logPath, line, "utf-8");
   }
   rotateIfNeeded() {
     try {
-      const stats = fs11.statSync(this.logPath);
+      const stats = fs12.statSync(this.logPath);
       if (stats.size > MAX_LOG_SIZE) {
-        const content = fs11.readFileSync(this.logPath, "utf-8");
+        const content = fs12.readFileSync(this.logPath, "utf-8");
         const halfIdx = content.indexOf("\n", Math.floor(content.length / 2));
         if (halfIdx > 0) {
-          fs11.writeFileSync(this.logPath, content.slice(halfIdx + 1), "utf-8");
+          fs12.writeFileSync(this.logPath, content.slice(halfIdx + 1), "utf-8");
         }
       }
     } catch {
@@ -4355,39 +4652,39 @@ var DaemonLogger = class {
 };
 
 // src/scheduled-tasks/daemon/PidManager.ts
-import * as fs12 from "fs";
-import * as path14 from "path";
+import * as fs13 from "fs";
+import * as path15 from "path";
 var CONFIG_DIR2 = ".serviceme";
 var PID_FILE = "scheduler.pid";
 var PidManager = class {
   constructor(workspacePath, options = {}) {
-    this.pidPath = options.pidPath ?? path14.join(workspacePath, CONFIG_DIR2, PID_FILE);
+    this.pidPath = options.pidPath ?? path15.join(workspacePath, CONFIG_DIR2, PID_FILE);
   }
   getPidPath() {
     return this.pidPath;
   }
   writePid(pid) {
-    const dir = path14.dirname(this.pidPath);
-    if (!fs12.existsSync(dir)) {
-      fs12.mkdirSync(dir, { recursive: true });
+    const dir = path15.dirname(this.pidPath);
+    if (!fs13.existsSync(dir)) {
+      fs13.mkdirSync(dir, { recursive: true });
     }
-    fs12.writeFileSync(this.pidPath, String(pid), "utf-8");
+    fs13.writeFileSync(this.pidPath, String(pid), "utf-8");
   }
   readPid() {
     let stat5;
     try {
-      stat5 = fs12.statSync(this.pidPath);
+      stat5 = fs13.statSync(this.pidPath);
     } catch {
       return null;
     }
     if (!stat5.isFile()) return null;
-    const raw = fs12.readFileSync(this.pidPath, "utf-8").trim();
+    const raw = fs13.readFileSync(this.pidPath, "utf-8").trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isNaN(pid) ? null : pid;
   }
   removePid() {
-    if (fs12.existsSync(this.pidPath)) {
-      fs12.unlinkSync(this.pidPath);
+    if (fs13.existsSync(this.pidPath)) {
+      fs13.unlinkSync(this.pidPath);
     }
   }
   isProcessRunning(pid) {
@@ -4408,13 +4705,13 @@ var PidManager = class {
 };
 
 // src/scheduled-tasks/daemon/SchedulerDaemon.ts
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 import * as os5 from "os";
-import * as path18 from "path";
+import * as path19 from "path";
 
 // src/scheduled-tasks/executors/GithubCopilotCliExecutor.ts
 import { spawn as spawn3 } from "child_process";
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 
 // src/scheduled-tasks/executors/timeout.ts
 function resolveConfiguredTimeoutMs(timeoutSeconds, defaultTimeoutMs) {
@@ -4449,7 +4746,7 @@ function redactArgs(args) {
 function writeDiagnostic(message) {
   const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH;
   if (logPath) {
-    fs13.appendFileSync(logPath, message);
+    fs14.appendFileSync(logPath, message);
     return;
   }
   process.stderr.write(message);
@@ -4655,15 +4952,15 @@ ${body}`.trim()
 
 // src/scheduled-tasks/executors/ShellExecutor.ts
 import { spawn as spawn4 } from "child_process";
-import * as fs14 from "fs";
-import * as path15 from "path";
+import * as fs15 from "fs";
+import * as path16 from "path";
 var MAX_OUTPUT_BYTES2 = 1024 * 1024;
 var DEFAULT_TIMEOUT_MS4 = 6e4;
 var POSIX_SHELL_CANDIDATES = ["bash.exe", "sh.exe"];
 function resolveShellExecution(script, options = {}) {
   const platform3 = options.platform ?? process.platform;
   const env = options.env ?? process.env;
-  const fileExists = options.fileExists ?? fs14.existsSync;
+  const fileExists = options.fileExists ?? fs15.existsSync;
   if (platform3 === "win32") {
     const posixShell = usesPosixShellSyntax(script) ? findWindowsPosixShell(env, fileExists) : null;
     if (posixShell) {
@@ -4708,10 +5005,10 @@ function findWindowsPosixShell(env, fileExists) {
     if (fileExists(candidate)) return candidate;
   }
   const pathValue = env.Path ?? env.PATH ?? "";
-  for (const dir of pathValue.split(path15.win32.delimiter)) {
+  for (const dir of pathValue.split(path16.win32.delimiter)) {
     if (!dir) continue;
     for (const executable of POSIX_SHELL_CANDIDATES) {
-      const candidate = path15.win32.join(dir, executable);
+      const candidate = path16.win32.join(dir, executable);
       if (fileExists(candidate) && !isWindowsWslLauncher(candidate)) {
         return candidate;
       }
@@ -4720,13 +5017,13 @@ function findWindowsPosixShell(env, fileExists) {
   return null;
 }
 function isWindowsWslLauncher(candidate) {
-  const normalized = path15.win32.normalize(candidate).toLowerCase();
+  const normalized = path16.win32.normalize(candidate).toLowerCase();
   return normalized.endsWith("\\windows\\system32\\bash.exe") || normalized.endsWith("\\windows\\syswow64\\bash.exe");
 }
 function writeDiagnostic2(message) {
   const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH;
   if (logPath) {
-    fs14.appendFileSync(logPath, message);
+    fs15.appendFileSync(logPath, message);
     return;
   }
   process.stderr.write(message);
@@ -4868,10 +5165,10 @@ function getExecutor(taskType) {
 }
 
 // src/scheduled-tasks/TaskConfigManager.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import * as fs15 from "fs";
+import { randomUUID as randomUUID4 } from "crypto";
+import * as fs16 from "fs";
 import * as os4 from "os";
-import * as path16 from "path";
+import * as path17 from "path";
 import {
   createServicemeError as createServicemeError8,
   isScheduledTasksConfig,
@@ -4901,7 +5198,7 @@ function v1ContainerShape(value) {
 }
 function defaultWorkspaceContext() {
   const home = os4.homedir() || "/";
-  return { path: home, name: path16.basename(home) || home };
+  return { path: home, name: path17.basename(home) || home };
 }
 function requireNonEmptyString(payload, field, taskType) {
   if (!isRecord2(payload) || typeof payload[field] !== "string" || !payload[field].trim()) {
@@ -4936,10 +5233,10 @@ var TaskConfigManager = class {
     return this.configPath;
   }
   readConfig() {
-    if (!fs15.existsSync(this.configPath)) {
+    if (!fs16.existsSync(this.configPath)) {
       return emptyConfig();
     }
-    const raw = fs15.readFileSync(this.configPath, "utf-8");
+    const raw = fs16.readFileSync(this.configPath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -4992,7 +5289,7 @@ var TaskConfigManager = class {
       const target = this.migrationFailuresPath ?? getMigrationFailuresPath();
       const prior = (() => {
         try {
-          return JSON.parse(fs15.readFileSync(target, "utf-8"));
+          return JSON.parse(fs16.readFileSync(target, "utf-8"));
         } catch {
           return [];
         }
@@ -5005,8 +5302,8 @@ var TaskConfigManager = class {
         snippet: raw.slice(0, 500),
         recordedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      fs15.mkdirSync(path16.dirname(target), { recursive: true });
-      fs15.writeFileSync(target, JSON.stringify(failures, null, "	"), "utf-8");
+      fs16.mkdirSync(path17.dirname(target), { recursive: true });
+      fs16.writeFileSync(target, JSON.stringify(failures, null, "	"), "utf-8");
     } catch (writeError) {
       this.warn(
         `TaskConfigManager: also failed to write migration-failures log: ${String(writeError)}`
@@ -5014,13 +5311,13 @@ var TaskConfigManager = class {
     }
   }
   writeConfig(config) {
-    const dir = path16.dirname(this.configPath);
-    if (!fs15.existsSync(dir)) {
-      fs15.mkdirSync(dir, { recursive: true });
+    const dir = path17.dirname(this.configPath);
+    if (!fs16.existsSync(dir)) {
+      fs16.mkdirSync(dir, { recursive: true });
     }
     const tmp = `${this.configPath}.tmp`;
-    fs15.writeFileSync(tmp, JSON.stringify(config, null, "	"), "utf-8");
-    fs15.renameSync(tmp, this.configPath);
+    fs16.writeFileSync(tmp, JSON.stringify(config, null, "	"), "utf-8");
+    fs16.renameSync(tmp, this.configPath);
   }
   listTasks() {
     return this.readConfig().tasks;
@@ -5042,7 +5339,7 @@ var TaskConfigManager = class {
     const config = this.readConfig();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const task = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       name: input.name,
       description: input.description,
       enabled: input.enabled ?? true,
@@ -5297,9 +5594,9 @@ var TaskExecutionEngine = class {
 };
 
 // src/scheduled-tasks/TaskLogManager.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import * as fs16 from "fs";
-import * as path17 from "path";
+import { randomUUID as randomUUID5 } from "crypto";
+import * as fs17 from "fs";
+import * as path18 from "path";
 var MAX_LOGS = 200;
 function emptyLogFile() {
   return { logs: [] };
@@ -5328,11 +5625,11 @@ var TaskLogManager = class {
     return this.logPath;
   }
   readLogFile() {
-    if (!fs16.existsSync(this.logPath)) {
+    if (!fs17.existsSync(this.logPath)) {
       return emptyLogFile();
     }
     try {
-      const raw = fs16.readFileSync(this.logPath, "utf-8");
+      const raw = fs17.readFileSync(this.logPath, "utf-8");
       const parsed = JSON.parse(raw);
       const file = validateAndRepairLogFile(parsed);
       if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.logs) || parsed.logs.length !== file.logs.length) {
@@ -5348,26 +5645,26 @@ var TaskLogManager = class {
   }
   backupCorruptedFile() {
     try {
-      if (fs16.existsSync(this.logPath)) {
+      if (fs17.existsSync(this.logPath)) {
         const backupPath = `${this.logPath}.corrupted.${Date.now()}`;
-        fs16.copyFileSync(this.logPath, backupPath);
+        fs17.copyFileSync(this.logPath, backupPath);
       }
     } catch {
     }
   }
   writeLogFile(file) {
-    const dir = path17.dirname(this.logPath);
-    if (!fs16.existsSync(dir)) {
-      fs16.mkdirSync(dir, { recursive: true });
+    const dir = path18.dirname(this.logPath);
+    if (!fs17.existsSync(dir)) {
+      fs17.mkdirSync(dir, { recursive: true });
     }
     const tmp = `${this.logPath}.tmp`;
-    fs16.writeFileSync(tmp, JSON.stringify(file, null, "	"), "utf-8");
-    fs16.renameSync(tmp, this.logPath);
+    fs17.writeFileSync(tmp, JSON.stringify(file, null, "	"), "utf-8");
+    fs17.renameSync(tmp, this.logPath);
   }
   appendLog(input) {
     const file = this.readLogFile();
     const log = {
-      id: randomUUID4(),
+      id: randomUUID5(),
       taskId: input.taskId,
       taskName: input.taskName,
       startedAt: input.startedAt,
@@ -5422,12 +5719,12 @@ var SchedulerDaemon = class {
     this.lastRun = /* @__PURE__ */ new Map();
     this.taskRunning = /* @__PURE__ */ new Set();
     this.workspacePath = workspacePath;
-    const configDir = path18.join(workspacePath, ".serviceme");
+    const configDir = path19.join(workspacePath, ".serviceme");
     this.configManager = new TaskConfigManager({
-      configPath: path18.join(configDir, "scheduled-tasks.json")
+      configPath: path19.join(configDir, "scheduled-tasks.json")
     });
     this.logManager = new TaskLogManager({
-      logPath: path18.join(configDir, "scheduled-tasks-log.json")
+      logPath: path19.join(configDir, "scheduled-tasks-log.json")
     });
     this.pidManager = new PidManager(workspacePath);
     this.logger = new DaemonLogger(workspacePath);
@@ -5479,8 +5776,8 @@ var SchedulerDaemon = class {
     const configPath = this.configManager.getConfigPath();
     const dir = configPath.substring(0, configPath.lastIndexOf("/"));
     try {
-      if (fs17.existsSync(dir)) {
-        this.watcher = fs17.watch(dir, (_eventType, filename) => {
+      if (fs18.existsSync(dir)) {
+        this.watcher = fs18.watch(dir, (_eventType, filename) => {
           if (filename === "scheduled-tasks.json") {
             this.logger.log("info", "Config file changed, reconciling...");
           }
@@ -5633,9 +5930,9 @@ function matchCronField(field, value) {
 }
 
 // src/scheduled-tasks/daemon/SchedulerDaemonV2.ts
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 import * as os6 from "os";
-import * as path19 from "path";
+import * as path20 from "path";
 var TICK_INTERVAL2 = 1e3;
 var MIN_SCHEDULE_INTERVAL2 = 1e3;
 var SCHEDULER_LOG_FILENAME2 = "scheduler.log";
@@ -5655,7 +5952,7 @@ var SchedulerDaemonV2 = class {
     this.logManager = options.logManager ?? new TaskLogManager();
     this.pidManager = options.pidManager ?? new PidManager("", { pidPath: getSchedulerPidPath() });
     this.logger = options.logger ?? new DaemonLogger(os6.homedir(), {
-      logPath: path19.join(path19.dirname(this.pidManager.getPidPath()), SCHEDULER_LOG_FILENAME2)
+      logPath: path20.join(path20.dirname(this.pidManager.getPidPath()), SCHEDULER_LOG_FILENAME2)
     });
     this.getExecutor = options.getExecutor ?? getExecutor;
     this.tryAcquireLock = options.tryAcquireLock ?? (() => true);
@@ -5713,7 +6010,7 @@ var SchedulerDaemonV2 = class {
     const now = Date.now();
     for (const task of config.tasks) {
       if (!task.enabled) continue;
-      if (!fs18.existsSync(task.workspace.path)) {
+      if (!fs19.existsSync(task.workspace.path)) {
         this.disableTaskForMissingWorkspace(task, config);
         continue;
       }
@@ -5870,21 +6167,21 @@ function matchCronField2(field, value) {
 }
 
 // src/scheduled-tasks/migration/MigrateToGlobal.ts
-import * as fs19 from "fs";
-import * as path20 from "path";
+import * as fs20 from "fs";
+import * as path21 from "path";
 import { isScheduledTasksConfigV1 as isScheduledTasksConfigV12, migrateV1ToV2 as migrateV1ToV22 } from "@serviceme/devtools-protocol";
 var WORKSPACE_DIR = ".serviceme";
 var V1_FILENAME = "scheduled-tasks.json";
 function defaultProbe(workspacePath) {
   return {
     path: workspacePath,
-    name: path20.basename(workspacePath) || workspacePath
+    name: path21.basename(workspacePath) || workspacePath
   };
 }
 function readV1Config(v1Path) {
   let raw;
   try {
-    raw = fs19.readFileSync(v1Path, "utf-8");
+    raw = fs20.readFileSync(v1Path, "utf-8");
   } catch (err) {
     return {
       ok: false,
@@ -5907,27 +6204,27 @@ function readV1Config(v1Path) {
 }
 function safeDelete(filePath) {
   try {
-    fs19.unlinkSync(filePath);
+    fs20.unlinkSync(filePath);
   } catch {
   }
 }
 function ensureDir(filePath) {
-  const dir = path20.dirname(filePath);
-  if (!fs19.existsSync(dir)) {
-    fs19.mkdirSync(dir, { recursive: true });
+  const dir = path21.dirname(filePath);
+  if (!fs20.existsSync(dir)) {
+    fs20.mkdirSync(dir, { recursive: true });
   }
 }
 function readJsonFile(filePath) {
-  if (!fs19.existsSync(filePath)) return null;
+  if (!fs20.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs19.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs20.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeJsonFile(filePath, data) {
   ensureDir(filePath);
-  fs19.writeFileSync(filePath, JSON.stringify(data, null, "	"), "utf-8");
+  fs20.writeFileSync(filePath, JSON.stringify(data, null, "	"), "utf-8");
 }
 function disambiguateName(task, existingNames, workspaceName) {
   if (!existingNames.has(task.name)) {
@@ -5957,8 +6254,8 @@ async function migrateToGlobal(options) {
   const conflicts = [];
   const issues = [];
   for (const workspacePath of options.workspacePaths) {
-    const v1Path = path20.join(workspacePath, WORKSPACE_DIR, V1_FILENAME);
-    if (!fs19.existsSync(v1Path)) continue;
+    const v1Path = path21.join(workspacePath, WORKSPACE_DIR, V1_FILENAME);
+    if (!fs20.existsSync(v1Path)) continue;
     const v1 = readV1Config(v1Path);
     if (!v1.ok) {
       failures.push({
@@ -6000,8 +6297,8 @@ async function migrateToGlobal(options) {
   if (migrated > 0) {
     ensureDir(globalConfigPath);
     const tmp = `${globalConfigPath}.tmp`;
-    fs19.writeFileSync(tmp, JSON.stringify(baseConfig, null, "	"), "utf-8");
-    fs19.renameSync(tmp, globalConfigPath);
+    fs20.writeFileSync(tmp, JSON.stringify(baseConfig, null, "	"), "utf-8");
+    fs20.renameSync(tmp, globalConfigPath);
   }
   if (failures.length > priorFailures.length) {
     writeJsonFile(migrationFailuresPath, failures);
@@ -6018,8 +6315,8 @@ async function migrateToGlobal(options) {
 
 // src/scheduled-tasks/workspace-probe/WorkspaceProbe.ts
 import { spawn as spawn5 } from "child_process";
-import * as fs20 from "fs";
-import * as path21 from "path";
+import * as fs21 from "fs";
+import * as path22 from "path";
 var DEFAULT_TIMEOUT_MS5 = 2e3;
 var GitTimeoutError = class extends Error {
   constructor() {
@@ -6082,8 +6379,8 @@ var WorkspaceProbe = class {
     }
   }
   async probe(workspacePath) {
-    const name = path21.basename(workspacePath) || workspacePath;
-    if (!workspacePath || !fs20.existsSync(workspacePath)) {
+    const name = path22.basename(workspacePath) || workspacePath;
+    if (!workspacePath || !fs21.existsSync(workspacePath)) {
       return {
         workspace: { path: workspacePath, name },
         error: "path-not-found"
@@ -6235,8 +6532,8 @@ var SkillReconciler = class {
 };
 
 // src/skills/SkillStore.ts
-import * as fs21 from "fs/promises";
-import * as path22 from "path";
+import * as fs22 from "fs/promises";
+import * as path23 from "path";
 var USER_SKILL_MARKER_FILE = ".serviceme-skill.json";
 var LEGACY_USER_SKILL_MARKER_FILE = ".ms-devtools-skill.json";
 var WORKSPACE_SKILLS_ROOT_RELATIVE = ".github/skills";
@@ -6252,7 +6549,7 @@ var SkillStore = class {
   constructor(options) {
     this.workspacePath = options.workspacePath;
     this.userSkillsRoot = options.userSkillsRoot;
-    this.fileSystem = options.fileSystem ?? fs21;
+    this.fileSystem = options.fileSystem ?? fs22;
   }
   normalizeRemoteSkillId(remoteId) {
     if (remoteId.startsWith("official/")) {
@@ -6271,10 +6568,10 @@ var SkillStore = class {
     return WORKSPACE_SKILLS_MARKER_RELATIVE;
   }
   getUserSkillPath(skillId) {
-    return path22.join(this.userSkillsRoot, skillId);
+    return path23.join(this.userSkillsRoot, skillId);
   }
   async listWorkspaceSkillIds() {
-    const skillsRootPath = path22.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE);
+    const skillsRootPath = path23.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE);
     try {
       const entries = await this.fileSystem.readdir(skillsRootPath, {
         withFileTypes: true
@@ -6298,7 +6595,7 @@ var SkillStore = class {
     const targetDir = this.getUserSkillPath(skillId);
     await this.fileSystem.mkdir(targetDir, { recursive: true });
     await this.fileSystem.writeFile(
-      path22.join(targetDir, USER_SKILL_MARKER_FILE),
+      path23.join(targetDir, USER_SKILL_MARKER_FILE),
       JSON.stringify({ skillId, installedBy: "serviceme" }, null, 2),
       "utf-8"
     );
@@ -6307,7 +6604,7 @@ var SkillStore = class {
     await this.migrateLegacyUserSkillMarker(skillId);
     try {
       const marker = await this.fileSystem.readFile(
-        path22.join(this.getUserSkillPath(skillId), USER_SKILL_MARKER_FILE),
+        path23.join(this.getUserSkillPath(skillId), USER_SKILL_MARKER_FILE),
         "utf-8"
       );
       const parsed = JSON.parse(marker);
@@ -6324,8 +6621,8 @@ var SkillStore = class {
    */
   async migrateLegacyUserSkillMarker(skillId) {
     const targetDir = this.getUserSkillPath(skillId);
-    const newPath = path22.join(targetDir, USER_SKILL_MARKER_FILE);
-    const legacyPath = path22.join(targetDir, LEGACY_USER_SKILL_MARKER_FILE);
+    const newPath = path23.join(targetDir, USER_SKILL_MARKER_FILE);
+    const legacyPath = path23.join(targetDir, LEGACY_USER_SKILL_MARKER_FILE);
     try {
       await this.fileSystem.readFile(newPath, "utf-8");
       return;
@@ -6338,12 +6635,12 @@ var SkillStore = class {
     }
   }
   async writeSkillFiles(skillId, scope, files) {
-    const root = scope === "workspace" ? path22.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE) : this.userSkillsRoot;
-    const targetDir = path22.join(root, skillId);
+    const root = scope === "workspace" ? path23.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE) : this.userSkillsRoot;
+    const targetDir = path23.join(root, skillId);
     await this.fileSystem.mkdir(targetDir, { recursive: true });
     for (const file of files) {
-      const filePath = path22.join(targetDir, file.path);
-      await this.fileSystem.mkdir(path22.dirname(filePath), { recursive: true });
+      const filePath = path23.join(targetDir, file.path);
+      await this.fileSystem.mkdir(path23.dirname(filePath), { recursive: true });
       await this.fileSystem.writeFile(filePath, file.content, "utf-8");
       if (file.executable) {
         try {
@@ -6356,8 +6653,8 @@ var SkillStore = class {
 };
 
 // src/submit/index.ts
-import * as fs22 from "fs/promises";
-import * as path23 from "path";
+import * as fs23 from "fs/promises";
+import * as path24 from "path";
 
 // src/submit/types.ts
 var SubmitError = class extends Error {
@@ -6407,14 +6704,14 @@ var SubmitClient = class {
       throw new SubmitError(v.reason ?? "unknown", v.detail ?? "validation denied");
     }
     const localRepoPath = getRepoDir(repoId);
-    const targetDir = path23.join(localRepoPath, "skills", skillName);
-    await fs22.mkdir(targetDir, { recursive: true });
+    const targetDir = path24.join(localRepoPath, "skills", skillName);
+    await fs23.mkdir(targetDir, { recursive: true });
     for (const f of files) {
-      const full = path23.join(targetDir, f.path);
-      await fs22.mkdir(path23.dirname(full), { recursive: true });
+      const full = path24.join(targetDir, f.path);
+      await fs23.mkdir(path24.dirname(full), { recursive: true });
       const tmp = `${full}.${process.pid}.${Date.now()}.tmp`;
-      await fs22.writeFile(tmp, f.content, "utf8");
-      await fs22.rename(tmp, full);
+      await fs23.writeFile(tmp, f.content, "utf8");
+      await fs23.rename(tmp, full);
     }
     const commitMessage = `feat(skills): add ${skillName}`;
     const { commitSha } = await this.git.commit(localRepoPath, commitMessage);
@@ -6483,7 +6780,7 @@ function touchLastUsedAt(tools, id, when = /* @__PURE__ */ new Date()) {
 
 // src/toolbox/ToolboxStore.ts
 import * as fsp2 from "fs/promises";
-import * as path24 from "path";
+import * as path25 from "path";
 import { setTimeout as delay2 } from "timers/promises";
 
 // src/toolbox/types.ts
@@ -6518,11 +6815,11 @@ var LOCK_DIR_MODE2 = 448;
 var DEFAULT_LOCK_TIMEOUT_MS2 = 5e3;
 var DEFAULT_LOCK_RETRY_MS2 = 25;
 var TMP_SUFFIX2 = ".tmp";
-var WORKSPACE_TOOLBOX_RELATIVE_PATH = path24.join(".github", ".serviceme-toolbox.json");
+var WORKSPACE_TOOLBOX_RELATIVE_PATH = path25.join(".github", ".serviceme-toolbox.json");
 var LEGACY_WORKSPACE_TOOLBOX_FILENAME = ".ms-devtools-toolbox.json";
 async function migrateLegacyWorkspaceToolboxFile(filePath) {
   if (!filePath) return;
-  const legacyPath = path24.join(path24.dirname(filePath), LEGACY_WORKSPACE_TOOLBOX_FILENAME);
+  const legacyPath = path25.join(path25.dirname(filePath), LEGACY_WORKSPACE_TOOLBOX_FILENAME);
   if (legacyPath === filePath) return;
   try {
     await fsp2.access(filePath);
@@ -6567,7 +6864,7 @@ var FsToolboxFileBackend = class {
     }
   }
   async write(filePath, payload) {
-    await fsp2.mkdir(path24.dirname(filePath), { recursive: true });
+    await fsp2.mkdir(path25.dirname(filePath), { recursive: true });
     const tmpPath = `${filePath}${TMP_SUFFIX2}`;
     const bytes = Buffer.from(JSON.stringify(payload, null, "	"), "utf8");
     await fsp2.rm(tmpPath, { force: true });
@@ -6599,10 +6896,19 @@ function coercePersistedToolbox(parsed) {
 function isNodeError2(value) {
   return value instanceof Error && typeof value.code === "string";
 }
+function isProcessAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 var ToolboxFileLock = class {
   constructor(filePath, timeoutMs, retryMs) {
     this.acquired = false;
     this.dirPath = `${filePath}.lock`;
+    this.pidFilePath = path25.join(this.dirPath, "pid");
     this.timeoutMs = timeoutMs;
     this.retryMs = retryMs;
   }
@@ -6611,10 +6917,16 @@ var ToolboxFileLock = class {
     while (true) {
       try {
         await fsp2.mkdir(this.dirPath, { mode: LOCK_DIR_MODE2 });
+        await fsp2.writeFile(this.pidFilePath, String(process.pid), "utf8").catch(() => void 0);
         this.acquired = true;
         return;
       } catch (err) {
         if (!isNodeError2(err) || err.code !== "EEXIST") throw err;
+        const stale = await this.isStaleLock();
+        if (stale) {
+          await fsp2.rm(this.dirPath, { recursive: true, force: true });
+          continue;
+        }
         if (Date.now() - start >= this.timeoutMs) {
           throw new Error(`ToolboxStore lock acquisition timed out for ${this.dirPath}`);
         }
@@ -6622,6 +6934,16 @@ var ToolboxFileLock = class {
       }
     }
   }
+  async isStaleLock() {
+    try {
+      const pidStr = await fsp2.readFile(this.pidFilePath, "utf8");
+      const pid = Number.parseInt(pidStr.trim(), 10);
+      if (!Number.isFinite(pid) || pid <= 0) return true;
+      return !isProcessAlive2(pid);
+    } catch {
+      return true;
+    }
+  }
   async release() {
     if (!this.acquired) return;
     this.acquired = false;
@@ -6630,7 +6952,7 @@ var ToolboxFileLock = class {
 };
 function defaultWorkspacePath() {
   if (process.env.SERVICEME_NO_WORKSPACE_TOOLBOX === "1") return null;
-  return path24.join(process.cwd(), WORKSPACE_TOOLBOX_RELATIVE_PATH);
+  return path25.join(process.cwd(), WORKSPACE_TOOLBOX_RELATIVE_PATH);
 }
 var ToolboxStore = class {
   constructor(opts = {}) {
@@ -6937,6 +7259,7 @@ export {
   SCHEDULER_LOCK_FILENAME,
   SCHEDULER_LOG_FILENAME,
   SCHEDULER_PID_FILENAME,
+  SERVER_PROXY_GLOBAL_FILENAME,
   SERVICEME_DIR_NAME,
   SERVICEME_HOME_ENV,
   SKILL_DRAFTS_SUBDIR,
@@ -7004,6 +7327,7 @@ export {
   getSchedulerLockPath,
   getSchedulerLogPath,
   getSchedulerPidPath,
+  getServerProxyGlobalPath,
   getServicemeHome,
   getSkillDraftsDir,
   getToolboxJsonPath,
@@ -7014,6 +7338,7 @@ export {
   isUserRepo,
   matchesCron,
   mergeWithDefaults,
+  migrateLegacyServerProxyEnabled,
   migrateToGlobal,
   moveFiles,
   narrowRepoConfig,
@@ -7021,6 +7346,7 @@ export {
   parseAgentToolPermissions,
   parseIntervalMs,
   randomInstallationId,
+  readServerProxyGlobal,
   reindexOrder,
   reposFileSchema,
   resetUserHomeOverrides,
@@ -7035,6 +7361,7 @@ export {
   unzipFile,
   userRepoSchema as userRepoConfigSchema,
   validateReposFile,
-  validateTaskPayload
+  validateTaskPayload,
+  writeServerProxyGlobal
 };
 //# sourceMappingURL=index.mjs.map