@alan-ai-hq/agent-manager 0.1.80 → 0.1.82

package/dist/index.cjs

@@ -14973,7 +14973,7 @@ function resolveCommand(args, env) {
 
 // src/daemon.ts
 var import_node_crypto17 = require("crypto");
-var import_node_os11 = require("os");
+var import_node_os12 = require("os");
 
 // src/sleep-inhibitor.ts
 var import_node_child_process2 = require("child_process");
@@ -15240,7 +15240,7 @@ function describeError(error61) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.80";
+var AGENT_VERSION = "0.1.82";
 
 // src/daemon-worktree.ts
 var import_node_child_process3 = require("child_process");
@@ -15296,104 +15296,6 @@ function isInteractiveToolName(name, input2) {
 var ALAN_AGENT_WORKOS_USER_ID_PREFIX = "alan-agent:";
 var ALAN_AGENT_WORKOS_USER_ID_LIKE_PATTERN = `${ALAN_AGENT_WORKOS_USER_ID_PREFIX}%`;
 
-// ../shared/dist/constants/colors.js
-var CATEGORICAL_COLORS = {
-  slate: "#7280a0",
-  slateMuted: "#8892a4",
-  slateCool: "#6b7a96",
-  slateDeep: "#64748b",
-  slateClosed: "#7a8295",
-  slateLight: "#94a3b8",
-  slatePale: "#cbd5e1",
-  blue: "#5583b5",
-  blueMuted: "#6a90b0",
-  blueBright: "#3b82f6",
-  blueSoft: "#7d9fc2",
-  cyan: "#3a92a8",
-  cyanBright: "#2f9ab5",
-  cyanSoft: "#6dadb8",
-  teal: "#4895a5",
-  tealDeep: "#2e9e80",
-  green: "#3d9170",
-  greenBright: "#3a9c6f",
-  greenMuted: "#5a9a6a",
-  greenSoft: "#6daa94",
-  greenLeaf: "#74b080",
-  purple: "#7e6db2",
-  dubaiPurple: "#6366f1",
-  purpleMuted: "#9a6daa",
-  purpleSoft: "#9a8cbd",
-  violet: "#8b6bbf",
-  indigo: "#6b75d6",
-  indigoMuted: "#838cc0",
-  gold: "#b08a45",
-  goldMuted: "#a89248",
-  amber: "#c49a30",
-  yellow: "#eab308",
-  orange: "#c27058",
-  orangeDeep: "#c47d3a",
-  orangeBright: "#f97316",
-  orangeSoft: "#d49872",
-  orangePale: "#fdba74",
-  red: "#c25858",
-  redBright: "#ef4444",
-  redSoft: "#c47474",
-  pink: "#b25a8a",
-  pinkMuted: "#b86078",
-  pinkSoft: "#c07a9a",
-  rose: "#c44d8a",
-  bronze: "#8a8258",
-  avatarBlue: "#4a7fc4",
-  avatarPurple: "#7b62c4",
-  avatarOrange: "#c4703a"
-};
-var CATEGORICAL_COLOR_VALUES = Object.values(CATEGORICAL_COLORS);
-var CATEGORICAL_COLOR_VALUE_SET = new Set(CATEGORICAL_COLOR_VALUES);
-
-// ../shared/dist/constants/labels.js
-var LABEL_COLOR_PRESETS = {
-  bug: CATEGORICAL_COLORS.red,
-  feature: CATEGORICAL_COLORS.purple,
-  improvement: CATEGORICAL_COLORS.blue,
-  refactor: CATEGORICAL_COLORS.gold,
-  docs: CATEGORICAL_COLORS.green,
-  chore: CATEGORICAL_COLORS.slate,
-  design: CATEGORICAL_COLORS.pink,
-  research: CATEGORICAL_COLORS.cyan
-};
-var LABEL_COLOR_PALETTE = [
-  CATEGORICAL_COLORS.orange,
-  CATEGORICAL_COLORS.goldMuted,
-  CATEGORICAL_COLORS.greenMuted,
-  CATEGORICAL_COLORS.teal,
-  CATEGORICAL_COLORS.indigo,
-  CATEGORICAL_COLORS.purpleMuted,
-  CATEGORICAL_COLORS.pinkMuted,
-  CATEGORICAL_COLORS.bronze,
-  CATEGORICAL_COLORS.blueMuted
-];
-var LABEL_COLOR_CHOICES = [
-  CATEGORICAL_COLORS.slate,
-  CATEGORICAL_COLORS.blue,
-  CATEGORICAL_COLORS.purple,
-  CATEGORICAL_COLORS.green,
-  CATEGORICAL_COLORS.red,
-  CATEGORICAL_COLORS.orange,
-  CATEGORICAL_COLORS.gold,
-  CATEGORICAL_COLORS.pink,
-  CATEGORICAL_COLORS.cyan,
-  CATEGORICAL_COLORS.teal
-];
-var AVATAR_COLOR_PALETTE = [
-  CATEGORICAL_COLORS.avatarBlue,
-  CATEGORICAL_COLORS.avatarPurple,
-  CATEGORICAL_COLORS.indigo,
-  CATEGORICAL_COLORS.rose,
-  CATEGORICAL_COLORS.avatarOrange,
-  CATEGORICAL_COLORS.greenBright,
-  CATEGORICAL_COLORS.cyanBright
-];
-
 // ../shared/dist/constants/local-workspace.js
 var ALAN_DEFAULT_WORKSPACE_URI = "alan://workspace";
 function isAlanDefaultWorkspace(value2) {
@@ -15412,166 +15314,6 @@ Before create_task:
 4. Use list_team_labels and apply matching labels when creating or updating; do not invent label variants.
 5. Similarity hits are hints only \u2014 synthesize context and use judgment, not fixed thresholds.`;
 
-// ../shared/dist/constants/tasks.js
-var STATUS_OPTIONS = [
-  {
-    value: "backlog",
-    label: "Backlog",
-    color: CATEGORICAL_COLORS.slateMuted,
-    group: "not_started",
-    dotClass: "text-muted-foreground",
-    headerBg: "bg-muted/60"
-  },
-  {
-    value: "todo",
-    label: "Todo",
-    color: CATEGORICAL_COLORS.slateCool,
-    group: "not_started",
-    dotClass: "text-muted-foreground/70",
-    headerBg: "bg-muted/40"
-  },
-  {
-    value: "in_progress",
-    label: "In Progress",
-    color: CATEGORICAL_COLORS.amber,
-    group: "active",
-    dotClass: "text-amber-700 dark:text-amber-400",
-    headerBg: "bg-amber-400/15"
-  },
-  {
-    value: "in_review",
-    label: "In Review",
-    color: CATEGORICAL_COLORS.violet,
-    group: "active",
-    dotClass: "text-violet-500 dark:text-violet-400",
-    headerBg: "bg-violet-400/15"
-  },
-  {
-    value: "done",
-    label: "Done",
-    color: CATEGORICAL_COLORS.tealDeep,
-    group: "done",
-    dotClass: "text-teal-600 dark:text-teal-400",
-    headerBg: "bg-teal-400/15"
-  },
-  {
-    value: "cancelled",
-    label: "Cancelled",
-    color: CATEGORICAL_COLORS.slateClosed,
-    group: "closed",
-    dotClass: "text-muted-foreground/60",
-    headerBg: "bg-muted/60"
-  }
-];
-var DEFAULT_TEAM_STATUSES = STATUS_OPTIONS.map((o) => ({
-  id: o.value,
-  label: o.label,
-  color: o.color,
-  group: o.group
-}));
-var EPIC_STATUS_OPTIONS = [
-  {
-    value: "backlog",
-    label: "Backlog",
-    color: CATEGORICAL_COLORS.slateMuted,
-    group: "not_started"
-  },
-  {
-    value: "planned",
-    label: "Planned",
-    color: CATEGORICAL_COLORS.blueSoft,
-    group: "not_started"
-  },
-  {
-    value: "in_progress",
-    label: "In Progress",
-    color: CATEGORICAL_COLORS.amber,
-    group: "active"
-  },
-  {
-    value: "completed",
-    label: "Completed",
-    color: CATEGORICAL_COLORS.tealDeep,
-    group: "done"
-  },
-  {
-    value: "canceled",
-    label: "Canceled",
-    color: CATEGORICAL_COLORS.slateClosed,
-    group: "closed"
-  }
-];
-var DEFAULT_EPIC_STATUSES = EPIC_STATUS_OPTIONS.map((o) => ({
-  id: o.value,
-  label: o.label,
-  color: o.color,
-  group: o.group
-}));
-var PRIORITY_OPTIONS = [
-  {
-    value: "p0",
-    label: "Urgent",
-    detail: "Urgent",
-    color: CATEGORICAL_COLORS.redBright,
-    iconClass: "text-red-500/70",
-    flagClass: "text-red-600 dark:text-red-400"
-  },
-  {
-    value: "p1",
-    label: "High",
-    detail: "High",
-    color: CATEGORICAL_COLORS.orangeBright,
-    iconClass: "text-orange-500/70",
-    flagClass: "text-orange-600 dark:text-orange-400"
-  },
-  {
-    value: "p2",
-    label: "Medium",
-    detail: "Medium",
-    color: CATEGORICAL_COLORS.yellow,
-    iconClass: "text-amber-500/70 dark:text-amber-400/70",
-    flagClass: "text-amber-600 dark:text-amber-400"
-  },
-  {
-    value: "p3",
-    label: "Low",
-    detail: "Low",
-    color: CATEGORICAL_COLORS.blueBright,
-    iconClass: "text-blue-500/70 dark:text-blue-400/70",
-    flagClass: "text-blue-600 dark:text-blue-400"
-  },
-  {
-    value: "none",
-    label: "No priority",
-    detail: "No priority",
-    color: CATEGORICAL_COLORS.slateDeep,
-    iconClass: "text-muted-foreground/40",
-    flagClass: "text-muted-foreground/50"
-  }
-];
-
-// ../shared/dist/constants/workspace-retention.js
-var RESOURCE_CLASS_GC_TIME_MS = {
-  /**
-   * Small, stable, expensive-to-refetch descriptors: team lists, member lists,
-   * label sets, status metadata. Kilobytes that rarely change.
-   */
-  metadata: 30 * 6e4,
-  /** Everything not explicitly classified. The previous global default. */
-  standard: 10 * 6e4,
-  /**
-   * Large per-entity payloads: transcripts, diffs, file trees, image sets,
-   * paginated bulk lists. Megabytes that are cheap to re-fetch on return.
-   */
-  bulk: 9e4,
-  /**
-   * Immutable content addressed by a content hash (commit diffs). Retaining it
-   * is a pure win while it fits the budget, and the budget controller drops it
-   * first under pressure precisely because it can always be re-derived.
-   */
-  immutable: 60 * 6e4
-};
-
 // ../shared/dist/node/local-workspace.js
 var import_node_fs2 = require("fs");
 var import_node_os2 = require("os");
@@ -37211,16 +36953,6 @@ function isCodexTransientReconnectNotice(message) {
   return false;
 }
 
-// ../shared/dist/utils/agent-run-status.js
-var ACTIVE_AGENT_RUN_STATUSES = [
-  "pending",
-  "awaiting_agent",
-  "awaiting_sandbox",
-  "dispatched",
-  "running"
-];
-var STOPPABLE_AGENT_RUN_STATUSES = [...ACTIVE_AGENT_RUN_STATUSES, "paused"];
-
 // ../shared/dist/agent/types.js
 function resolveEffectiveBackendKind(backendKind) {
   if (backendKind === "codex")
@@ -39191,6 +38923,8 @@ function classifyCliErrorDetailed(stderr, _exitCode, opts) {
     "grok build usage balance"
   ) || has("payment required") && has("status 402"))
     return specForErrorKind("usage_limit");
+  if (has("creditserror", "no payment method")) return specForErrorKind("subscription_required");
+  if (has("datapolicyerror", "requires explicit opt in")) return specForErrorKind("model_mismatch");
   if (has("no chat found", "chat not found", "session not found", "could not resume"))
     return specForErrorKind("resume_failed");
   if (has("rate_limit", "rate limit") || /\b429\b/.test(haystack))
@@ -45773,6 +45507,20 @@ function classifyOpenCodeError(errorRecord, fallbackMessage) {
       recoveryClass: "user_fixable"
     };
   }
+  if (name === "CreditsError") {
+    return {
+      message: extracted || fallbackMessage,
+      errorKind: "subscription_required",
+      recoveryClass: "user_fixable"
+    };
+  }
+  if (name === "DataPolicyError") {
+    return {
+      message: extracted || fallbackMessage,
+      errorKind: "model_mismatch",
+      recoveryClass: "user_fixable"
+    };
+  }
   const message = extracted || fallbackMessage;
   const detailed = classifyCliErrorDetailed(message, 1);
   return { message, errorKind: detailed.errorKind, recoveryClass: detailed.recoveryClass };
@@ -49117,9 +48865,14 @@ function removeAlanOwnedLocalArtifacts() {
 
 // src/provider-model-discovery.ts
 var import_node_fs12 = require("fs");
+var import_node_os6 = require("os");
+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);
+var OPENCODE_ZEN_STATIC_BILLING = new Map(
+  OPENCODE_ZEN_MODELS.filter((model) => model.billing).map((model) => [model.id, model.billing])
+);
 var CLAUDE_MODEL_ID_PATTERN = /claude-(?:sonnet|opus|haiku|fable)-[a-z0-9][a-z0-9-]*/g;
 var CLAUDE_MODEL_ALIASES = ["sonnet", "opus", "haiku", "fable"];
 var CLAUDE_MODEL_ALIAS_SET = new Set(CLAUDE_MODEL_ALIASES);
@@ -49191,7 +48944,7 @@ function extractCodexDiscoveredModelIdsFromDebugJson(value2) {
   }
   return [...new Set(ids)];
 }
-var OPENCODE_MODEL_ID_LINE_PATTERN = /^[a-z0-9][\w.-]*\/[\w.-]+$/i;
+var OPENCODE_MODEL_ID_LINE_PATTERN = /^[a-z0-9][\w.-]*(?:\/[\w.-]+)+$/i;
 function parseOpenCodeVerboseModelOutput(text) {
   const entries = [];
   const lines = text.split(/\r?\n/);
@@ -49379,7 +49132,190 @@ async function probeJsonOrTextModels(executable, env, argSets, options) {
   }
   return [];
 }
+var OPENCODE_ZEN_MODELS_URL = "https://opencode.ai/zen/v1/models";
+var ZEN_ENTITLEMENT_TIMEOUT_MS = 5e3;
+var OPENCODE_ZEN_ID_PREFIX = "opencode/";
+function readOpenCodeZenCredential(env) {
+  const direct = env.OPENCODE_API_KEY?.trim();
+  if (direct) return direct;
+  return readZenCredentialFromAuthDocument(readOpenCodeAuthDocument(env) ?? void 0);
+}
+function readOpenCodeAuthDocument(env) {
+  const injected = env.OPENCODE_AUTH_CONTENT?.trim();
+  if (injected) return injected;
+  const dataHome = env.XDG_DATA_HOME?.trim() || (0, import_node_path11.join)((0, import_node_os6.homedir)(), ".local", "share");
+  try {
+    return (0, import_node_fs12.readFileSync)((0, import_node_path11.join)(dataHome, "opencode", "auth.json"), "utf8");
+  } catch {
+    return null;
+  }
+}
+var OPENCODE_PROVIDER_ENV_KEYS = [
+  ["OPENROUTER_API_KEY", "openrouter"],
+  ["ANTHROPIC_API_KEY", "anthropic"],
+  ["OPENAI_API_KEY", "openai"],
+  ["GEMINI_API_KEY", "google"],
+  ["GOOGLE_GENERATIVE_AI_API_KEY", "google"],
+  ["XAI_API_KEY", "xai"],
+  ["GROQ_API_KEY", "groq"],
+  ["MISTRAL_API_KEY", "mistral"],
+  ["DEEPSEEK_API_KEY", "deepseek"]
+];
+function readConfiguredOpenCodeProviders(env) {
+  const configured = /* @__PURE__ */ new Set(["opencode", "opencode-go"]);
+  const document2 = readOpenCodeAuthDocument(env);
+  if (document2) {
+    try {
+      const parsed = JSON.parse(document2);
+      if (parsed && typeof parsed === "object") {
+        for (const providerId of Object.keys(parsed)) configured.add(providerId);
+      }
+    } catch {
+    }
+  }
+  for (const [envKey, namespace] of OPENCODE_PROVIDER_ENV_KEYS) {
+    if (env[envKey]?.trim()) configured.add(namespace);
+  }
+  return configured;
+}
+function readZenCredentialFromAuthDocument(content) {
+  const trimmed = content?.trim();
+  if (!trimmed) return null;
+  try {
+    const entry = JSON.parse(trimmed).opencode;
+    if (!entry || typeof entry !== "object") return null;
+    const { key, access: access2 } = entry;
+    for (const candidate of [key, access2]) {
+      if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function fetchZenEntitledModelIds(credential) {
+  try {
+    const response = await fetch(OPENCODE_ZEN_MODELS_URL, {
+      headers: credential ? { Authorization: `Bearer ${credential}` } : {},
+      signal: AbortSignal.timeout(ZEN_ENTITLEMENT_TIMEOUT_MS)
+    });
+    if (!response.ok) return null;
+    const data = (await response.json())?.data;
+    if (!Array.isArray(data)) return null;
+    const ids = data.map((entry) => entry?.id).filter((id) => typeof id === "string" && id.length > 0);
+    return ids.length > 0 ? new Set(ids) : null;
+  } catch {
+    return null;
+  }
+}
+function applyZenEntitlement(discovery, entitled) {
+  const zenId = (id) => `${OPENCODE_ZEN_ID_PREFIX}${id}`;
+  const kept = discovery.models.filter(
+    (id) => !id.startsWith(OPENCODE_ZEN_ID_PREFIX) || entitled.has(id.slice(OPENCODE_ZEN_ID_PREFIX.length))
+  );
+  const keptSet = new Set(kept);
+  const scannedSet = new Set(discovery.models);
+  const unscannedEntitled = [...entitled].map(zenId);
+  return {
+    ...discovery,
+    models: [...kept, ...unscannedEntitled.filter((id) => !keptSet.has(id))],
+    catalogModels: [
+      ...discovery.catalogModels ?? discovery.models,
+      ...unscannedEntitled.filter((id) => !scannedSet.has(id))
+    ]
+  };
+}
+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_path11.join)((0, import_node_os6.homedir)(), ".cache");
+  let parsed;
+  try {
+    parsed = JSON.parse(
+      (0, import_node_fs12.readFileSync)((0, import_node_path11.join)(cacheHome, ...OPENCODE_CATALOGUE_CACHE_SEGMENTS), "utf8")
+    );
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const variants = {};
+  const billing = {};
+  const deprecated = /* @__PURE__ */ new Set();
+  for (const providerKey of OPENCODE_CACHE_PROVIDER_KEYS) {
+    const models = parsed[providerKey]?.models;
+    if (!models || typeof models !== "object") continue;
+    for (const [modelId, entry] of Object.entries(models)) {
+      if (!entry || typeof entry !== "object") continue;
+      const id = `${providerKey}/${modelId}`;
+      const record2 = entry;
+      if (record2.status === "deprecated") deprecated.add(id);
+      const options = Array.isArray(record2.reasoning_options) ? record2.reasoning_options : [];
+      const effort = options.find(
+        (option2) => option2?.type === "effort"
+      );
+      const values = Array.isArray(effort?.values) ? effort.values.filter((value2) => typeof value2 === "string") : [];
+      if (values.length > 0) variants[id] = values;
+      const cost = record2.cost;
+      if (typeof cost?.input === "number" && typeof cost?.output === "number") {
+        billing[id] = cost.input === 0 && cost.output === 0 ? "free" : "paid";
+      }
+    }
+  }
+  return Object.keys(variants).length > 0 || Object.keys(billing).length > 0 ? { variants, billing, deprecated } : null;
+}
+function hydrateOpenCodeMetadata(discovery, cache2) {
+  const ids = /* @__PURE__ */ new Set([...discovery.models, ...discovery.catalogModels ?? []]);
+  const modelVariants = { ...discovery.modelVariants };
+  const modelBilling = { ...discovery.modelBilling };
+  for (const id of ids) {
+    if (!Object.hasOwn(modelVariants, id) && cache2.variants[id]) {
+      modelVariants[id] = cache2.variants[id];
+    }
+    if (!Object.hasOwn(modelBilling, id) && cache2.billing[id]) {
+      modelBilling[id] = cache2.billing[id];
+    }
+  }
+  return {
+    ...discovery,
+    ...Object.keys(modelVariants).length > 0 ? { modelVariants } : {},
+    ...Object.keys(modelBilling).length > 0 ? { modelBilling } : {}
+  };
+}
 async function discoverOpenCodeModels(executable, env) {
+  const credential = readOpenCodeZenCredential(env);
+  const [rawScan, entitled] = await Promise.all([
+    scanOpenCodeModels(executable, env),
+    fetchZenEntitledModelIds(credential)
+  ]);
+  const configured = readConfiguredOpenCodeProviders(env);
+  const inConfigured = (id) => {
+    const slash = id.indexOf("/");
+    return slash > 0 && configured.has(id.slice(0, slash));
+  };
+  const scanned = {
+    ...rawScan,
+    models: rawScan.models.filter(inConfigured),
+    ...rawScan.catalogModels ? { catalogModels: rawScan.catalogModels.filter(inConfigured) } : {}
+  };
+  const filtered = entitled ? applyZenEntitlement(scanned, entitled) : scanned;
+  const cache2 = readOpenCodeCatalogueCache(env);
+  const hydrated = cache2 ? hydrateOpenCodeMetadata(filtered, cache2) : filtered;
+  const keyEntitled = credential && entitled ? entitled : null;
+  const withoutDeprecated = cache2 ? hydrated.models.filter(
+    (id) => !cache2.deprecated.has(id) || keyEntitled !== null && id.startsWith(OPENCODE_ZEN_ID_PREFIX) && keyEntitled.has(id.slice(OPENCODE_ZEN_ID_PREFIX.length))
+  ) : hydrated.models;
+  return {
+    ...hydrated,
+    models: credential ? withoutDeprecated : filterZenToFreeModels(withoutDeprecated, hydrated.modelBilling)
+  };
+}
+function filterZenToFreeModels(models, billing) {
+  return models.filter((id) => {
+    if (!id.startsWith("opencode/") && !id.startsWith("opencode-go/")) return true;
+    return (billing?.[id] ?? OPENCODE_ZEN_STATIC_BILLING.get(id)) === "free";
+  });
+}
+async function scanOpenCodeModels(executable, env) {
   const verbose = await runCliProbeAsync(
     executable,
     withModelProbeEnv(env),
@@ -49642,6 +49578,7 @@ function discoverCapabilities() {
         available,
         ...version2 ? { version: version2 } : {},
         models: modelDiscovery?.models ?? [],
+        ...modelDiscovery?.catalogModels ? { catalogModels: modelDiscovery.catalogModels } : {},
         ...modelDiscovery?.modelVariants ? { modelVariants: modelDiscovery.modelVariants } : {},
         ...modelDiscovery?.modelBilling ? { modelBilling: modelDiscovery.modelBilling } : {},
         lastCheckedAt: now,
@@ -49889,8 +49826,8 @@ function scheduleRuntimeModelScan(getBaseMetadata, options) {
 var import_node_crypto16 = require("crypto");
 var import_node_fs20 = require("fs");
 var import_node_http = __toESM(require("http"), 1);
-var import_node_os10 = require("os");
-var import_node_path22 = require("path");
+var import_node_os11 = require("os");
+var import_node_path23 = require("path");
 
 // ../../node_modules/engine.io-client/build/esm-debug/transports/polling-xhr.node.js
 var XMLHttpRequestModule = __toESM(require_XMLHttpRequest(), 1);
@@ -53450,8 +53387,8 @@ Object.assign(lookup, {
 var import_node_child_process7 = require("child_process");
 var import_node_crypto5 = require("crypto");
 var import_node_fs13 = require("fs");
-var import_node_os6 = require("os");
-var import_node_path11 = require("path");
+var import_node_os7 = require("os");
+var import_node_path12 = require("path");
 var import_node_url = require("url");
 var BINDING_SWITCH_GIT_METHODS = [
   "git.status",
@@ -53503,8 +53440,8 @@ 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_fs13.mkdirSync)(barrierDir, { recursive: true });
-  const readyPath = (0, import_node_path11.join)(barrierDir, "ready");
-  const releasePath = (0, import_node_path11.join)(barrierDir, "release");
+  const readyPath = (0, import_node_path12.join)(barrierDir, "ready");
+  const releasePath = (0, import_node_path12.join)(barrierDir, "release");
   (0, import_node_fs13.writeFileSync)(readyPath, "ready\n");
   const deadline = Date.now() + 5e3;
   while (!(0, import_node_fs13.existsSync)(releasePath)) {
@@ -53521,8 +53458,8 @@ 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_fs13.mkdirSync)(barrierDir, { recursive: true });
-  const readyPath = (0, import_node_path11.join)(barrierDir, "ready");
-  const releasePath = (0, import_node_path11.join)(barrierDir, "release");
+  const readyPath = (0, import_node_path12.join)(barrierDir, "ready");
+  const releasePath = (0, import_node_path12.join)(barrierDir, "release");
   (0, import_node_fs13.writeFileSync)(readyPath, "ready\n");
   const deadline = Date.now() + 5e3;
   while (!(0, import_node_fs13.existsSync)(releasePath)) {
@@ -53663,7 +53600,7 @@ function acquireCheckpointRepositoryLocks(repoRoot) {
     "checkpoint_lock_unavailable"
   );
   const locks = {
-    headLockPath: (0, import_node_path11.join)(gitDir, "HEAD.lock"),
+    headLockPath: (0, import_node_path12.join)(gitDir, "HEAD.lock"),
     headLockHeld: false,
     indexLockPath: `${indexPath}.lock`,
     indexLockHeld: false,
@@ -53705,8 +53642,8 @@ function assertCheckpointHead(repoRoot, expectedRef, expectedHeadSha) {
   }
 }
 function createCheckpointIndexBaseline(repoRoot, checkpointSha) {
-  const tempDir = (0, import_node_fs13.mkdtempSync)((0, import_node_path11.join)((0, import_node_os6.tmpdir)(), "alan-checkpoint-index-"));
-  const indexPath = (0, import_node_path11.join)(tempDir, "index");
+  const tempDir = (0, import_node_fs13.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,
@@ -53767,7 +53704,7 @@ function commonRequest(params) {
   return {
     switchId: requiredString2(params, "switchId"),
     repoKey: requiredString2(params, "repoKey"),
-    repoPath: (0, import_node_path11.resolve)(requiredString2(params, "repoPath"))
+    repoPath: (0, import_node_path12.resolve)(requiredString2(params, "repoPath"))
   };
 }
 function assertCommitSha(sha, key) {
@@ -53801,8 +53738,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_path11.isAbsolute)(urlValue) || urlValue.startsWith("./") || urlValue.startsWith("../")) {
-    const absolute = (0, import_node_path11.isAbsolute)(urlValue) ? urlValue : (0, import_node_path11.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;
@@ -53868,24 +53805,24 @@ function inspectedRemoteUrl(repoRoot, params) {
   return urls[0];
 }
 function isPathContained2(childPath, parentPath) {
-  const rel = (0, import_node_path11.relative)((0, import_node_path11.resolve)(parentPath), (0, import_node_path11.resolve)(childPath));
-  return rel === "" || !(0, import_node_path11.isAbsolute)(rel) && rel !== ".." && !rel.startsWith(`..${import_node_path11.sep}`);
+  const rel = (0, import_node_path12.relative)((0, import_node_path12.resolve)(parentPath), (0, import_node_path12.resolve)(childPath));
+  return rel === "" || !(0, import_node_path12.isAbsolute)(rel) && rel !== ".." && !rel.startsWith(`..${import_node_path12.sep}`);
 }
 function canonicalPathWithMissingTail(path2) {
   const missingSegments = [];
-  let cursor = (0, import_node_path11.resolve)(path2);
+  let cursor = (0, import_node_path12.resolve)(path2);
   while (!(0, import_node_fs13.existsSync)(cursor)) {
-    const parent = (0, import_node_path11.dirname)(cursor);
+    const parent = (0, import_node_path12.dirname)(cursor);
     if (parent === cursor) {
       throw new BindingSwitchGitError(
         "path_canonicalization_failed",
         "The selected path has no existing canonical ancestor"
       );
     }
-    missingSegments.unshift((0, import_node_path11.basename)(cursor));
+    missingSegments.unshift((0, import_node_path12.basename)(cursor));
     cursor = parent;
   }
-  return (0, import_node_path11.join)(import_node_fs13.realpathSync.native(cursor), ...missingSegments);
+  return (0, import_node_path12.join)(import_node_fs13.realpathSync.native(cursor), ...missingSegments);
 }
 function assertCanonicalPathContained(childPath, parentPath, code, message) {
   if (!isPathContained2(
@@ -53896,7 +53833,7 @@ function assertCanonicalPathContained(childPath, parentPath, code, message) {
   }
 }
 function alanWorktreeRoot(projectRoot) {
-  return (0, import_node_path11.join)((0, import_node_path11.dirname)(projectRoot), `${(0, import_node_path11.basename)(projectRoot)}-alan-worktrees`);
+  return (0, import_node_path12.join)((0, import_node_path12.dirname)(projectRoot), `${(0, import_node_path12.basename)(projectRoot)}-alan-worktrees`);
 }
 function resolveRepositoryRoot(requestedPath) {
   if (!(0, import_node_fs13.existsSync)(requestedPath)) {
@@ -53912,7 +53849,7 @@ function resolveRepositoryRoot(requestedPath) {
       "The selected folder is not inside a Git repository"
     );
   }
-  return import_node_fs13.realpathSync.native((0, import_node_path11.resolve)(root.stdout.trim()));
+  return import_node_fs13.realpathSync.native((0, import_node_path12.resolve)(root.stdout.trim()));
 }
 function listWorktrees(repoRoot) {
   return runGit(repoRoot, ["worktree", "list", "--porcelain"]).split("\n\n").flatMap((entry) => {
@@ -53931,7 +53868,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_path11.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"
@@ -53939,7 +53876,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_path11.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) {
@@ -53975,8 +53912,8 @@ function updateLengthPrefixed(hash2, value2) {
   hash2.update("\0");
 }
 function proposedTreeSha(repoRoot, headSha) {
-  const tempDir = (0, import_node_fs13.mkdtempSync)((0, import_node_path11.join)((0, import_node_os6.tmpdir)(), "alan-switch-index-"));
-  const indexPath = (0, import_node_path11.join)(tempDir, "index");
+  const tempDir = (0, import_node_fs13.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) {
@@ -54438,12 +54375,12 @@ async function prepareWorktree(params) {
       "Worktree preparation requires the Project's main checkout"
     );
   }
-  const worktreePath = (0, import_node_path11.resolve)(requiredString2(params, "worktreePath"));
+  const worktreePath = (0, import_node_path12.resolve)(requiredString2(params, "worktreePath"));
   const managedRoot = alanWorktreeRoot(projectRoot);
   const pathError = "The destination worktree path is outside the Alan-managed worktree directory";
-  const intendedManagedRoot = (0, import_node_path11.join)(
-    import_node_fs13.realpathSync.native((0, import_node_path11.dirname)(managedRoot)),
-    (0, import_node_path11.basename)(managedRoot)
+  const intendedManagedRoot = (0, import_node_path12.join)(
+    import_node_fs13.realpathSync.native((0, import_node_path12.dirname)(managedRoot)),
+    (0, import_node_path12.basename)(managedRoot)
   );
   if (canonicalPathWithMissingTail(managedRoot) !== intendedManagedRoot) {
     throw new BindingSwitchGitError("worktree_path_not_authorized", pathError);
@@ -54503,7 +54440,7 @@ async function prepareWorktree(params) {
       );
     }
   }
-  (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(worktreePath), { recursive: true });
+  (0, import_node_fs13.mkdirSync)((0, import_node_path12.dirname)(worktreePath), { recursive: true });
   if (branchExists) {
     runGit(repoRoot, ["worktree", "add", worktreePath, branch], "worktree_prepare_failed");
     const currentHead = runGit(worktreePath, ["rev-parse", "HEAD"]);
@@ -54582,11 +54519,11 @@ async function executeBindingSwitchGitRpc(method, params) {
 
 // src/daemon-execute.ts
 var import_node_fs15 = require("fs");
-var import_node_path13 = require("path");
+var import_node_path14 = require("path");
 
 // src/cli-ensure-install.ts
 var import_node_child_process8 = require("child_process");
-var import_node_os7 = require("os");
+var import_node_os8 = require("os");
 var CLI_RUNTIME_VERSIONS_ENV = "ALAN_CLI_RUNTIME_VERSIONS";
 var INSTALLABLE_PROVIDER_PACKAGES = {
   claude_cli: { npmPackage: "@anthropic-ai/claude-code", command: "claude", label: "Claude Code" },
@@ -54614,7 +54551,7 @@ function versionPolicy(npmPackage) {
 }
 function runNpmInstall(installSpec, env, timeoutMs) {
   return new Promise((resolve15) => {
-    const isWin = (0, import_node_os7.platform)() === "win32";
+    const isWin = (0, import_node_os8.platform)() === "win32";
     let child;
     try {
       child = (0, import_node_child_process8.spawn)("npm", ["install", "-g", installSpec], {
@@ -54684,13 +54621,13 @@ function ensureProviderCliInstalled(backendKind, options) {
 }
 
 // src/core-agent.ts
-var import_node_os9 = require("os");
+var import_node_os10 = require("os");
 
 // src/mcp-registration.ts
 var import_node_crypto6 = require("crypto");
 var import_node_fs14 = require("fs");
-var import_node_os8 = require("os");
-var import_node_path12 = require("path");
+var import_node_os9 = require("os");
+var import_node_path13 = require("path");
 
 // ../../node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string4, ptr) {
@@ -55631,7 +55568,7 @@ var inspectAlanMcpThroughProviderCli = async (backendKind, expectedUrl, home) =>
   return result;
 };
 async function waitForConfigLock(lockPath) {
-  (0, import_node_fs14.mkdirSync)((0, import_node_path12.dirname)(lockPath), { recursive: true });
+  (0, import_node_fs14.mkdirSync)((0, import_node_path13.dirname)(lockPath), { recursive: true });
   const startedAt = Date.now();
   while (true) {
     try {
@@ -55712,8 +55649,8 @@ function atomicWriteManagedConfig(path2, content) {
     (0, import_node_fs14.rmSync)(pendingPath, { force: true });
   }
 }
-async function configureAntigravityApiKeyMode(home = (0, import_node_os8.homedir)()) {
-  const path2 = (0, import_node_path12.join)(home, ".gemini", "antigravity-cli", "settings.json");
+async function configureAntigravityApiKeyMode(home = (0, import_node_os9.homedir)()) {
+  const path2 = (0, import_node_path13.join)(home, ".gemini", "antigravity-cli", "settings.json");
   const releaseLock = await waitForConfigLock(`${path2}.alan-lock`);
   try {
     const existingContent = (0, import_node_fs14.existsSync)(path2) ? (0, import_node_fs14.readFileSync)(path2, "utf8") : "";
@@ -55726,13 +55663,13 @@ async function configureAntigravityApiKeyMode(home = (0, import_node_os8.homedir
     releaseLock();
   }
 }
-async function ensureAlanMcpRegistered(backendKind, registration, home = (0, import_node_os8.homedir)(), inspectCli = inspectAlanMcpThroughProviderCli) {
+async function ensureAlanMcpRegistered(backendKind, registration, home = (0, import_node_os9.homedir)(), inspectCli = inspectAlanMcpThroughProviderCli) {
   try {
     const mcpServers = buildAlanMcpServers(registration);
     const files = alanMcpConfigFilesForBackend(backendKind, mcpServers, home);
     const paths = [];
     for (const file2 of files) {
-      (0, import_node_fs14.mkdirSync)((0, import_node_path12.dirname)(file2.path), { recursive: true });
+      (0, import_node_fs14.mkdirSync)((0, import_node_path13.dirname)(file2.path), { recursive: true });
       const releaseLock = await waitForConfigLock(`${file2.path}.alan-lock`);
       try {
         const current = (0, import_node_fs14.existsSync)(file2.path) ? (0, import_node_fs14.readFileSync)(file2.path, "utf8") : null;
@@ -55797,7 +55734,7 @@ async function ensureAlanMcpRegistered(backendKind, registration, home = (0, imp
     return { ok: false, paths: [], error: err instanceof Error ? err.message : String(err) };
   }
 }
-async function restoreStaticAlanMcp(backendKind, apiUrl, home = (0, import_node_os8.homedir)()) {
+async function restoreStaticAlanMcp(backendKind, apiUrl, home = (0, import_node_os9.homedir)()) {
   let url3;
   try {
     url3 = new URL("/mcp", apiUrl).toString();
@@ -55813,7 +55750,7 @@ async function restoreStaticAlanMcp(backendKind, apiUrl, home = (0, import_node_
     verification: { method: "file" }
   }));
 }
-async function verifyAlanMcpRegistered(backendKind, home = (0, import_node_os8.homedir)(), inspectCli = inspectAlanMcpThroughProviderCli) {
+async function verifyAlanMcpRegistered(backendKind, home = (0, import_node_os9.homedir)(), inspectCli = inspectAlanMcpThroughProviderCli) {
   const files = alanMcpConfigFilesForBackend(backendKind, {}, home);
   const missing = files.map((f) => f.path).filter((p) => !(0, import_node_fs14.existsSync)(p));
   const presentEntries = files.map((file2) => ({
@@ -56125,7 +56062,7 @@ var CoreAgent = class _CoreAgent extends BaseMachineAgent {
     if (backendKind === "antigravity_cli" && augmented.GEMINI_API_KEY?.trim()) {
       await configureAntigravityApiKeyMode(augmented.HOME ?? augmented.USERPROFILE);
     }
-    if ((0, import_node_os9.platform)() !== "win32") {
+    if ((0, import_node_os10.platform)() !== "win32") {
       const home = augmented.HOME ?? "/home/user";
       const extraPaths = [`${home}/.local/node/bin`, `${home}/.local/bin`];
       const separator = ":";
@@ -73174,24 +73111,24 @@ async function handleAgentExecute(ctx, payload) {
   let workspaceReadiness = inspectWorkspaceReadiness(workspaceRequired ? cwd : void 0);
   const expectedRepoUrls = [
     ...(payload.repoLocalPaths ?? []).filter(
-      (repo) => explicitWorkspacePath ? (0, import_node_path13.resolve)(repo.localPath) === (0, import_node_path13.resolve)(explicitWorkspacePath) : false
+      (repo) => explicitWorkspacePath ? (0, import_node_path14.resolve)(repo.localPath) === (0, import_node_path14.resolve)(explicitWorkspacePath) : false
     ).map((repo) => repo.repoUrl),
     ...payload.localRepoUrls ?? []
   ];
   if (workspaceReadiness.code === "workspace_missing" && explicitWorkspacePath && !payload.worktreeInfo) {
-    const previousPath = (0, import_node_path13.resolve)(explicitWorkspacePath);
+    const previousPath = (0, import_node_path14.resolve)(explicitWorkspacePath);
     const remembered = workspaceRelocations.get(previousPath);
     const rememberedPath = remembered?.canonicalPath;
     const relocated = rememberedPath && workspaceMatchesExpectedRepositories({
       workspacePath: rememberedPath,
       expectedRepoUrls
-    }) ? (0, import_node_path13.resolve)(rememberedPath) : discoverRelocatedWorkspace({
+    }) ? (0, import_node_path14.resolve)(rememberedPath) : discoverRelocatedWorkspace({
       missingPath: explicitWorkspacePath,
       approvedWorkspacePaths: payload.approvedWorkspacePaths,
       expectedRepoUrls
     });
     if (relocated) {
-      if (!remembered || (0, import_node_path13.resolve)(remembered.canonicalPath) !== relocated) {
+      if (!remembered || (0, import_node_path14.resolve)(remembered.canonicalPath) !== relocated) {
         workspaceRelocations.set(previousPath, {
           conversationId: payload.conversationId,
           runId: payload.runId,
@@ -73975,7 +73912,7 @@ function transcriptGraceExpired(observedAt, now, graceMs) {
 // src/native-hook-inbox.ts
 var import_node_crypto8 = require("crypto");
 var import_node_fs16 = require("fs");
-var import_node_path14 = require("path");
+var import_node_path15 = require("path");
 var INBOX_FILE_VERSION = 1;
 var DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
 var DEFAULT_MAX_ENTRIES = 1e4;
@@ -74022,8 +73959,8 @@ var EncryptedNativeHookInbox = class {
     };
     const monotonic = process.hrtime.bigint().toString().padStart(20, "0");
     const prefix = `${String(Date.now()).padStart(13, "0")}-${monotonic}-${envelope.eventId}`;
-    const temporaryPath = (0, import_node_path14.join)(this.path, `.${prefix}-${(0, import_node_crypto8.randomUUID)()}.tmp`);
-    const finalPath = (0, import_node_path14.join)(this.path, `${prefix}.event`);
+    const temporaryPath = (0, import_node_path15.join)(this.path, `.${prefix}-${(0, import_node_crypto8.randomUUID)()}.tmp`);
+    const finalPath = (0, import_node_path15.join)(this.path, `${prefix}.event`);
     (0, import_node_fs16.writeFileSync)(temporaryPath, JSON.stringify(file2), { mode: 384, flag: "wx" });
     (0, import_node_fs16.chmodSync)(temporaryPath, 384);
     (0, import_node_fs16.renameSync)(temporaryPath, finalPath);
@@ -74041,9 +73978,9 @@ var EncryptedNativeHookInbox = class {
     const result = { attempted: 0, acknowledged: 0, deferred: 0 };
     const names = encryptedEntryNames(this.path).filter((name) => name.endsWith(".event")).slice(0, Math.max(0, limit));
     for (const name of names) {
-      const sourcePath = (0, import_node_path14.join)(this.path, name);
+      const sourcePath = (0, import_node_path15.join)(this.path, name);
       const claimedName = `${name.slice(0, -".event".length)}.processing-${(0, import_node_crypto8.randomUUID)()}`;
-      const claimedPath = (0, import_node_path14.join)(this.path, claimedName);
+      const claimedPath = (0, import_node_path15.join)(this.path, claimedName);
       try {
         (0, import_node_fs16.renameSync)(sourcePath, claimedPath);
       } catch {
@@ -74090,14 +74027,14 @@ var EncryptedNativeHookInbox = class {
       if (name.endsWith(".quarantine")) continue;
       const marker = name.indexOf(".processing-");
       if (marker === -1) continue;
-      const claimedPath = (0, import_node_path14.join)(this.path, name);
-      const eventPath = (0, import_node_path14.join)(this.path, `${name.slice(0, marker)}.event`);
+      const claimedPath = (0, import_node_path15.join)(this.path, name);
+      const eventPath = (0, import_node_path15.join)(this.path, `${name.slice(0, marker)}.event`);
       if ((0, import_node_fs16.existsSync)(eventPath)) (0, import_node_fs16.rmSync)(claimedPath, { force: true });
       else (0, import_node_fs16.renameSync)(claimedPath, eventPath);
     }
   }
   enforceBounds() {
-    const entries = encryptedEntryNames(this.path).filter((name) => name.endsWith(".event")).map((name) => ({ name, bytes: (0, import_node_fs16.statSync)((0, import_node_path14.join)(this.path, name)).size }));
+    const entries = encryptedEntryNames(this.path).filter((name) => name.endsWith(".event")).map((name) => ({ name, bytes: (0, import_node_fs16.statSync)((0, import_node_path15.join)(this.path, name)).size }));
     const totalBytes = entries.reduce((sum, entry) => sum + entry.bytes, 0);
     if (entries.length > this.maxEntries || totalBytes > this.maxBytes) {
       throw new Error(
@@ -74107,13 +74044,13 @@ var EncryptedNativeHookInbox = class {
   }
 };
 function nativeHookInboxPath(configPath) {
-  return (0, import_node_path14.join)((0, import_node_path14.dirname)(configPath), "native-hook-inbox");
+  return (0, import_node_path15.join)((0, import_node_path15.dirname)(configPath), "native-hook-inbox");
 }
 
 // src/native-transcript-cursor.ts
 var import_node_crypto9 = require("crypto");
 var import_node_fs17 = require("fs");
-var import_node_path15 = require("path");
+var import_node_path16 = require("path");
 var CURSOR_FILE_VERSION = 1;
 function nativeTranscriptCursorKey(input2) {
   return (0, import_node_crypto9.createHash)("sha256").update(`${input2.provider}\0${input2.externalSessionId}\0${input2.transcriptPath}`).digest("base64url");
@@ -74144,7 +74081,7 @@ var NativeTranscriptCursorStore = class {
     return parsed.entries;
   }
   persist() {
-    (0, import_node_fs17.mkdirSync)((0, import_node_path15.dirname)(this.path), { recursive: true, mode: 448 });
+    (0, import_node_fs17.mkdirSync)((0, import_node_path16.dirname)(this.path), { recursive: true, mode: 448 });
     const pendingPath = `${this.path}.pending-${process.pid}-${(0, import_node_crypto9.randomBytes)(6).toString("hex")}`;
     try {
       (0, import_node_fs17.writeFileSync)(
@@ -74550,7 +74487,7 @@ var ObservableMap = class extends Map {
 
 // src/run-journal.ts
 var import_node_fs19 = require("fs");
-var import_node_path16 = require("path");
+var import_node_path17 = require("path");
 var JOURNAL_VERSION = 1;
 var INTERRUPTED_ENTRY_TTL_MS = 24 * 60 * 6e4;
 function isEntry(value2) {
@@ -74694,7 +74631,7 @@ var RuntimeRunJournal = class {
   }
   persist() {
     const pendingPath = `${this.path}.pending`;
-    (0, import_node_fs19.mkdirSync)((0, import_node_path16.dirname)(this.path), { recursive: true });
+    (0, import_node_fs19.mkdirSync)((0, import_node_path17.dirname)(this.path), { recursive: true });
     try {
       (0, import_node_fs19.writeFileSync)(
         pendingPath,
@@ -74735,13 +74672,13 @@ var RunStartGate = class {
 var import_node_buffer2 = require("buffer");
 var import_node_crypto12 = require("crypto");
 var import_promises2 = require("fs/promises");
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
 
 // ../shared/dist/node/skill-package.js
 var import_node_buffer = require("buffer");
 var import_node_crypto11 = require("crypto");
 var import_promises = require("fs/promises");
-var import_node_path17 = require("path");
+var import_node_path18 = require("path");
 var import_yaml = __toESM(require_dist2(), 1);
 
 // ../shared/dist/skills/domain.js
@@ -75165,7 +75102,7 @@ async function inspectSkillPackage(packageRoot, options = {}) {
   }
   const inspectedFiles = await Promise.all(files.map(readPackageFile));
   inspectedFiles.sort(comparePackageFiles);
-  const parsedMetadata = parseSkillMetadata(inspectedFiles.find((file2) => file2.manifest.path === "SKILL.md")?.bytes, options.expectedName === void 0 ? (0, import_node_path17.basename)(root) : options.expectedName);
+  const parsedMetadata = parseSkillMetadata(inspectedFiles.find((file2) => file2.manifest.path === "SKILL.md")?.bytes, options.expectedName === void 0 ? (0, import_node_path18.basename)(root) : options.expectedName);
   const manifestFiles = inspectedFiles.map((file2) => file2.manifest);
   const diagnostics = [
     ...parsedMetadata.conformance,
@@ -75189,7 +75126,7 @@ async function readSkillPackageFile(packageRoot, path2, expectedSha256) {
   if (!normalizedPath || normalizedPath !== path2 || normalizedPath.includes("\\") || components.some((component) => !component || component === "." || component === "..")) {
     throw new SkillPackageError("INVALID_PATH", `Invalid Skill package path: ${path2}`, path2);
   }
-  const absolutePath = await (0, import_promises.realpath)((0, import_node_path17.resolve)(root, ...components)).catch(() => null);
+  const absolutePath = await (0, import_promises.realpath)((0, import_node_path18.resolve)(root, ...components)).catch(() => null);
   if (!absolutePath || normalizeRelativePath(root, absolutePath) !== normalizedPath) {
     throw new SkillPackageError("INVALID_PATH", `Skill package file was not found: ${path2}`, path2);
   }
@@ -75210,7 +75147,7 @@ async function readSkillPackageFile(packageRoot, path2, expectedSha256) {
   return { file: read.manifest, bytes: read.bytes };
 }
 async function requirePackageRoot(packageRoot) {
-  const root = await (0, import_promises.realpath)((0, import_node_path17.resolve)(packageRoot)).catch(() => null);
+  const root = await (0, import_promises.realpath)((0, import_node_path18.resolve)(packageRoot)).catch(() => null);
   if (!root) {
     throw new SkillPackageError("INVALID_PACKAGE_ROOT", "Skill package directory does not exist");
   }
@@ -75236,7 +75173,7 @@ async function walkPackage(root, ignoredPaths) {
   async function walkDirectory(directory) {
     const entries = await (0, import_promises.readdir)(directory, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = (0, import_node_path17.resolve)(directory, entry.name);
+      const absolutePath = (0, import_node_path18.resolve)(directory, entry.name);
       const normalizedPath = normalizeRelativePath(root, absolutePath);
       if (isIgnored(normalizedPath, entry.name, entry.isDirectory(), ignored))
         continue;
@@ -75303,12 +75240,12 @@ function globToRegExp(pattern) {
   return new RegExp(`${source}(?:/.*)?$`);
 }
 function normalizeRelativePath(root, absolutePath) {
-  const nativeRelativePath = (0, import_node_path17.relative)(root, absolutePath);
-  if (!nativeRelativePath || nativeRelativePath.startsWith(`..${import_node_path17.sep}`) || nativeRelativePath === "..") {
+  const nativeRelativePath = (0, import_node_path18.relative)(root, absolutePath);
+  if (!nativeRelativePath || nativeRelativePath.startsWith(`..${import_node_path18.sep}`) || nativeRelativePath === "..") {
     throw new SkillPackageError("INVALID_PATH", "Skill package path escapes its root");
   }
-  const normalized = nativeRelativePath.split(import_node_path17.sep).join("/").normalize("NFC");
-  if (normalized.includes("\0") || normalized.includes("\uFFFD") || import_node_path17.posix.isAbsolute(normalized)) {
+  const normalized = nativeRelativePath.split(import_node_path18.sep).join("/").normalize("NFC");
+  if (normalized.includes("\0") || normalized.includes("\uFFFD") || import_node_path18.posix.isAbsolute(normalized)) {
     throw new SkillPackageError("INVALID_PATH", `Invalid Skill package path: ${normalized}`);
   }
   return normalized;
@@ -75343,7 +75280,7 @@ function requireSafeFile(path2, size, normalizedPaths) {
   }
 }
 function isSecretPath(path2) {
-  const name = import_node_path17.posix.basename(path2).toLowerCase();
+  const name = import_node_path18.posix.basename(path2).toLowerCase();
   if (SECRET_BASENAMES.has(name) || name.startsWith(".env."))
     return true;
   return name.endsWith(".private-key.pem") || name.endsWith(".private-key.key");
@@ -75371,12 +75308,12 @@ function classifyFileKind(path2) {
     return "reference";
   if (path2.startsWith("assets/"))
     return "asset";
-  if (/^(?:licen[cs]e|copying|notice)(?:\.|$)/i.test(import_node_path17.posix.basename(path2)))
+  if (/^(?:licen[cs]e|copying|notice)(?:\.|$)/i.test(import_node_path18.posix.basename(path2)))
     return "license";
   return "other";
 }
 function classifyPreview(path2, bytes) {
-  const extension = import_node_path17.posix.extname(path2).toLowerCase();
+  const extension = import_node_path18.posix.extname(path2).toLowerCase();
   if (IMAGE_EXTENSIONS.has(extension))
     return "image";
   if (bytes.includes(0))
@@ -75480,7 +75417,7 @@ function normalizePackageReference(value2) {
   const withoutSuffix = trimmed.split(/[?#]/, 1)[0];
   if (!withoutSuffix)
     return null;
-  const normalized = import_node_path17.posix.normalize(withoutSuffix).replace(/^\.\//, "").normalize("NFC");
+  const normalized = import_node_path18.posix.normalize(withoutSuffix).replace(/^\.\//, "").normalize("NFC");
   if (normalized === ".." || normalized.startsWith("../"))
     return null;
   return normalized;
@@ -75717,9 +75654,9 @@ var LocalSkillSource = class {
    */
   async scanRootAsPackage(resolvedRoot, ignoredPaths, mode) {
     const directory = resolvedRoot.directory;
-    if (!await pathExists((0, import_node_path18.join)(directory, "SKILL.md"))) return null;
+    if (!await pathExists((0, import_node_path19.join)(directory, "SKILL.md"))) return null;
     const canonicalRoot = await (0, import_promises2.realpath)(directory).catch(() => directory);
-    const name = import_node_path18.default.basename(canonicalRoot);
+    const name = import_node_path19.default.basename(canonicalRoot);
     try {
       const fingerprint = await fingerprintPackage(canonicalRoot);
       const ignoreSignature = JSON.stringify(ignoredPaths);
@@ -75789,7 +75726,7 @@ var LocalSkillSource = class {
     );
     for (const entry of entries) {
       if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-      const candidatePath = (0, import_node_path18.join)(resolvedRoot.directory, entry.name);
+      const candidatePath = (0, import_node_path19.join)(resolvedRoot.directory, entry.name);
       const canonicalPath = await (0, import_promises2.realpath)(candidatePath).catch(() => null);
       if (!canonicalPath) {
         diagnostics.push({
@@ -75855,7 +75792,7 @@ async function fingerprintPackage(root) {
     entries.sort((left, right) => import_node_buffer2.Buffer.compare(import_node_buffer2.Buffer.from(left.name), import_node_buffer2.Buffer.from(right.name)));
     for (const entry of entries) {
       const path2 = relativeDirectory ? `${relativeDirectory}/${entry.name}` : entry.name;
-      const absolutePath = (0, import_node_path18.join)(directory, entry.name);
+      const absolutePath = (0, import_node_path19.join)(directory, entry.name);
       const metadata = await (0, import_promises2.lstat)(absolutePath);
       hash2.update(path2.normalize("NFC")).update("\0").update(
         entry.isDirectory() ? "d" : entry.isFile() ? "f" : entry.isSymbolicLink() ? "l" : "o"
@@ -75880,12 +75817,12 @@ async function canonicalDirectories(directories) {
   return [...new Set(canonical)];
 }
 function isWithinDirectory(parent, candidate) {
-  const path2 = (0, import_node_path18.relative)(parent, candidate);
-  return path2 !== ".." && !path2.startsWith(`..${import_node_path18.sep}`) && !(0, import_node_path18.isAbsolute)(path2);
+  const path2 = (0, import_node_path19.relative)(parent, candidate);
+  return path2 !== ".." && !path2.startsWith(`..${import_node_path19.sep}`) && !(0, import_node_path19.isAbsolute)(path2);
 }
 async function loadSkillSourceConfig(homeDirectory2) {
-  const configDirectory = (0, import_node_path18.join)(homeDirectory2, ".alan");
-  const configPath = (0, import_node_path18.join)(configDirectory, "config.toml");
+  const configDirectory = (0, import_node_path19.join)(homeDirectory2, ".alan");
+  const configPath = (0, import_node_path19.join)(configDirectory, "config.toml");
   await (0, import_promises2.mkdir)(configDirectory, { recursive: true, mode: 448 });
   let created = false;
   try {
@@ -75919,7 +75856,7 @@ async function resolveSkillScanInput(homeDirectory2, declared) {
   }
   const { config: config2 } = loaded;
   if (!config2.enabled) return { ...declared, roots: [], ignoredPaths: config2.ignoredPaths };
-  const draftsPath = (0, import_node_path18.resolve)((0, import_node_path18.join)(homeDirectory2, ".alan", "skill-sources"));
+  const draftsPath = (0, import_node_path19.resolve)((0, import_node_path19.join)(homeDirectory2, ".alan", "skill-sources"));
   const enabledProviders = new Set(declared.enabledProviderKinds ?? []);
   const configured = [];
   for (const source of config2.sources) {
@@ -75927,7 +75864,7 @@ async function resolveSkillScanInput(homeDirectory2, declared) {
       continue;
     }
     configured.push(
-      (0, import_node_path18.resolve)(source.path) === draftsPath ? { kind: "drafts", path: source.path, label: "Alan drafts" } : {
+      (0, import_node_path19.resolve)(source.path) === draftsPath ? { kind: "drafts", path: source.path, label: "Alan drafts" } : {
         kind: "configured",
         declarationId: source.declarationId,
         path: source.path,
@@ -75974,7 +75911,7 @@ function parseSkillSourceConfig(content, homeDirectory2) {
       value2.providers,
       `skills.sources[${index}].providers`
     );
-    const relativeDirectory = import_node_path18.default.relative(homeDirectory2, sourcePath);
+    const relativeDirectory = import_node_path19.default.relative(homeDirectory2, sourcePath);
     const inferredProviders = providerKindsForUserDirectory(relativeDirectory);
     const declaredProviders = value2.providers === void 0 ? inferredProviders : [...new Set(explicitProviders.map((provider) => provider.trim()).filter(Boolean))];
     const stale = staleCodexDeclaration(relativeDirectory, label, declaredProviders);
@@ -76004,7 +75941,7 @@ function requiredSourceId(value2, field) {
   }
   return value2;
 }
-function resolveSkillSourcePath(sourcePath, homeDirectory2, pathApi = import_node_path18.default) {
+function resolveSkillSourcePath(sourcePath, homeDirectory2, pathApi = import_node_path19.default) {
   const trimmed = sourcePath.trim();
   if (trimmed === "~") return pathApi.resolve(homeDirectory2);
   if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
@@ -76039,7 +75976,7 @@ function resolveScanRoots(roots, enabledProviderKinds) {
       ).entries()) {
         resolved.push({
           root,
-          directory: (0, import_node_path18.join)(root.path, relativeDirectory),
+          directory: (0, import_node_path19.join)(root.path, relativeDirectory),
           order: `1:${root.repositoryId}:${String(index).padStart(2, "0")}`
         });
       }
@@ -76098,7 +76035,7 @@ async function pathExists(candidate) {
 }
 async function hasManagedMarker(directory) {
   try {
-    await (0, import_promises2.access)((0, import_node_path18.join)(directory, ".alan-managed.json"));
+    await (0, import_promises2.access)((0, import_node_path19.join)(directory, ".alan-managed.json"));
     return true;
   } catch {
     return false;
@@ -76267,12 +76204,12 @@ var RuntimeSkillCoordinator = class {
 var import_node_buffer5 = require("buffer");
 var import_node_crypto15 = require("crypto");
 var import_promises5 = require("fs/promises");
-var import_node_path21 = require("path");
+var import_node_path22 = require("path");
 
 // src/skills/managed-skill-store.ts
 var import_node_crypto13 = require("crypto");
 var import_promises3 = require("fs/promises");
-var import_node_path19 = require("path");
+var import_node_path20 = require("path");
 var EMPTY_STATE = {
   version: 1,
   sources: {},
@@ -76291,7 +76228,7 @@ var ManagedSkillStore = class _ManagedSkillStore {
   static async open(baseDirectory) {
     await (0, import_promises3.mkdir)(baseDirectory, { recursive: true, mode: 448 });
     try {
-      const parsed = JSON.parse(await (0, import_promises3.readFile)((0, import_node_path19.join)(baseDirectory, "state.json"), "utf8"));
+      const parsed = JSON.parse(await (0, import_promises3.readFile)((0, import_node_path20.join)(baseDirectory, "state.json"), "utf8"));
       return new _ManagedSkillStore(baseDirectory, parseState(parsed), "verified");
     } catch (error61) {
       if (isMissingPath2(error61)) {
@@ -76390,8 +76327,8 @@ var ManagedSkillStore = class _ManagedSkillStore {
     this.canRemoveManagedFiles = true;
   }
   async persist() {
-    const statePath = (0, import_node_path19.join)(this.baseDirectory, "state.json");
-    const pendingPath = (0, import_node_path19.join)(
+    const statePath = (0, import_node_path20.join)(this.baseDirectory, "state.json");
+    const pendingPath = (0, import_node_path20.join)(
       this.baseDirectory,
       `.state.json.pending-${process.pid}-${(0, import_node_crypto13.randomBytes)(6).toString("hex")}`
     );
@@ -76476,7 +76413,7 @@ function isMissingPath2(error61) {
 var import_node_buffer3 = require("buffer");
 var import_node_crypto14 = require("crypto");
 var import_promises4 = require("fs/promises");
-var import_node_path20 = require("path");
+var import_node_path21 = require("path");
 var import_node_stream = require("stream");
 var import_node_zlib = require("zlib");
 var import_tar_stream = __toESM(require_tar_stream(), 1);
@@ -76485,7 +76422,7 @@ async function createSkillBundle(packageRoot) {
   const archive = (0, import_tar_stream.pack)();
   const tarPromise = collectStream(archive);
   for (const file2 of before.files) {
-    const bytes2 = await (0, import_promises4.readFile)((0, import_node_path20.join)(packageRoot, ...file2.path.split("/")));
+    const bytes2 = await (0, import_promises4.readFile)((0, import_node_path21.join)(packageRoot, ...file2.path.split("/")));
     await addArchiveEntry(archive, {
       name: file2.path,
       type: "file",
@@ -76600,13 +76537,13 @@ async function extractEntry(header, stream, destination, limits) {
   if (bytes.byteLength !== declaredSize) {
     throw new Error(`Skill archive file size is invalid: ${path2}`);
   }
-  const outputPath = (0, import_node_path20.join)(destination, ...path2.split("/"));
-  await (0, import_promises4.mkdir)((0, import_node_path20.dirname)(outputPath), { recursive: true, mode: 448 });
+  const outputPath = (0, import_node_path21.join)(destination, ...path2.split("/"));
+  await (0, import_promises4.mkdir)((0, import_node_path21.dirname)(outputPath), { recursive: true, mode: 448 });
   await (0, import_promises4.writeFile)(outputPath, bytes, { mode: (header.mode ?? 420) & 73 ? 493 : 420 });
 }
 function requireSafeArchivePath(value2) {
   const normalized = value2.replaceAll("\\", "/").normalize("NFC");
-  if (!normalized || normalized.startsWith("/") || normalized.includes("\0") || import_node_path20.posix.normalize(normalized) !== normalized || normalized === ".." || normalized.startsWith("../")) {
+  if (!normalized || normalized.startsWith("/") || normalized.includes("\0") || import_node_path21.posix.normalize(normalized) !== normalized || normalized === ".." || normalized.startsWith("../")) {
     throw new Error(`Skill archive contains an unsafe path: ${value2}`);
   }
   return normalized;
@@ -76685,14 +76622,14 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   }
   reconcileTail = Promise.resolve();
   static async open(options) {
-    const skillsStateDirectory = (0, import_node_path21.join)(options.homeDirectory, ".alan", "skills");
-    const managedSkillsDirectory = (0, import_node_path21.join)(options.homeDirectory, ".agents", "skills");
+    const skillsStateDirectory = (0, import_node_path22.join)(options.homeDirectory, ".alan", "skills");
+    const managedSkillsDirectory = (0, import_node_path22.join)(options.homeDirectory, ".agents", "skills");
     const store = await ManagedSkillStore.open(skillsStateDirectory);
     return new _RuntimeSkillManager(
       skillsStateDirectory,
       managedSkillsDirectory,
-      (0, import_node_path21.join)(options.homeDirectory, ".claude", "skills"),
-      (0, import_node_path21.join)(options.homeDirectory, ".alan", "sync-manifest.json"),
+      (0, import_node_path22.join)(options.homeDirectory, ".claude", "skills"),
+      (0, import_node_path22.join)(options.homeDirectory, ".alan", "sync-manifest.json"),
       store,
       options.downloadBundle ?? downloadBundleWithFetch,
       options.localSource ?? new LocalSkillSource(),
@@ -76851,7 +76788,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     if (!runtimeDirectory) {
       throw new Error("Selected Skill version is not installed on this runtime");
     }
-    const packageDirectory = (0, import_node_path21.join)(this.managedSkillsDirectory, runtimeDirectory);
+    const packageDirectory = (0, import_node_path22.join)(this.managedSkillsDirectory, runtimeDirectory);
     const marker = await readMarker(packageDirectory);
     if (!marker || marker.skillId !== invocation.skillId || marker.versionId !== invocation.versionId) {
       throw new Error("Selected Skill projection is missing or no longer owned by Alan");
@@ -76865,11 +76802,11 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   async reconcileUnlocked(manifest) {
     const desired = desiredSkillManifestSchema.parse(manifest);
     await (0, import_promises5.mkdir)(this.managedSkillsDirectory, { recursive: true, mode: 448 });
-    await (0, import_promises5.mkdir)((0, import_node_path21.join)(this.skillsStateDirectory, "cache", "sha256"), {
+    await (0, import_promises5.mkdir)((0, import_node_path22.join)(this.skillsStateDirectory, "cache", "sha256"), {
       recursive: true,
       mode: 448
     });
-    await (0, import_promises5.mkdir)((0, import_node_path21.join)(this.skillsStateDirectory, "tmp"), { recursive: true, mode: 448 });
+    await (0, import_promises5.mkdir)((0, import_node_path22.join)(this.skillsStateDirectory, "tmp"), { recursive: true, mode: 448 });
     const results = [];
     const nextProjections = {};
     for (const entry of desired.skills) {
@@ -76920,7 +76857,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     };
   }
   async reuseCurrentProjection(entry) {
-    const destination = (0, import_node_path21.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
+    const destination = (0, import_node_path22.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
     const marker = await readMarker(destination);
     if (marker?.skillId !== entry.skillId || marker.versionId !== entry.versionId || marker.contentHash !== entry.contentHash || !await packageMatches(destination, entry.contentHash)) {
       return null;
@@ -76929,19 +76866,19 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     return entry.contentHash;
   }
   async adoptLegacyProjection(entry) {
-    const destination = (0, import_node_path21.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
+    const destination = (0, import_node_path22.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
     if (await pathExists2(destination)) return;
     const manifest = await readLegacyManifest(this.legacyManifestPath);
     const legacy = manifest?.skills[entry.slug];
     if (!legacy) return;
-    const source = (0, import_node_path21.join)(this.managedSkillsDirectory, entry.slug);
+    const source = (0, import_node_path22.join)(this.managedSkillsDirectory, entry.slug);
     if (!await legacyFileMatches(source, legacy.hash) || !await packageMatches(source, entry.contentHash)) {
       return;
     }
     await (0, import_promises5.rename)(source, destination);
     try {
       await (0, import_promises5.writeFile)(
-        (0, import_node_path21.join)(destination, ".alan-managed.json"),
+        (0, import_node_path22.join)(destination, ".alan-managed.json"),
         `${JSON.stringify(markerFor(entry), null, 2)}
 `,
         { encoding: "utf8", flag: "wx", mode: 384 }
@@ -76950,19 +76887,19 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
       await (0, import_promises5.rename)(destination, source).catch(() => void 0);
       throw error61;
     }
-    await removeExactLegacySkill((0, import_node_path21.join)(this.compatibilitySkillsDirectory, entry.slug), legacy.hash);
+    await removeExactLegacySkill((0, import_node_path22.join)(this.compatibilitySkillsDirectory, entry.slug), legacy.hash);
   }
   async retireLegacySyncManifest() {
     const manifest = await readLegacyManifest(this.legacyManifestPath);
     if (!manifest) return;
     for (const [command, entry] of Object.entries(manifest.skills)) {
-      await removeExactLegacySkill((0, import_node_path21.join)(this.managedSkillsDirectory, command), entry.hash);
-      await removeExactLegacySkill((0, import_node_path21.join)(this.compatibilitySkillsDirectory, command), entry.hash);
+      await removeExactLegacySkill((0, import_node_path22.join)(this.managedSkillsDirectory, command), entry.hash);
+      await removeExactLegacySkill((0, import_node_path22.join)(this.compatibilitySkillsDirectory, command), entry.hash);
     }
     await (0, import_promises5.rm)(this.legacyManifestPath, { force: true });
   }
   async ensureCached(entry) {
-    const cacheDirectory = (0, import_node_path21.join)(
+    const cacheDirectory = (0, import_node_path22.join)(
       this.skillsStateDirectory,
       "cache",
       "sha256",
@@ -76976,7 +76913,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
         `Downloaded Skill bundle length ${bytes.byteLength} does not match ${entry.compressedBytes}`
       );
     }
-    const pendingDirectory = (0, import_node_path21.join)(
+    const pendingDirectory = (0, import_node_path22.join)(
       this.skillsStateDirectory,
       "tmp",
       `cache-${process.pid}-${(0, import_node_crypto15.randomBytes)(8).toString("hex")}`
@@ -76997,22 +76934,22 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     return cacheDirectory;
   }
   async project(entry, cacheDirectory) {
-    const destination = (0, import_node_path21.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
+    const destination = (0, import_node_path22.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
     const existing = await readMarker(destination);
     if (existing?.skillId === entry.skillId && existing.versionId === entry.versionId && existing.contentHash === entry.contentHash && await packageMatches(destination, entry.contentHash)) {
       await this.ensureCompatibilityProjection(entry, destination);
       return entry.contentHash;
     }
     const suffix = `${process.pid}-${(0, import_node_crypto15.randomBytes)(8).toString("hex")}`;
-    const pending = (0, import_node_path21.join)(this.managedSkillsDirectory, `.pending-${suffix}`);
-    const backup = (0, import_node_path21.join)(this.managedSkillsDirectory, `.backup-${suffix}`);
+    const pending = (0, import_node_path22.join)(this.managedSkillsDirectory, `.pending-${suffix}`);
+    const backup = (0, import_node_path22.join)(this.managedSkillsDirectory, `.backup-${suffix}`);
     let movedExisting = false;
     let installedPending = false;
     let completed = false;
     try {
       await (0, import_promises5.cp)(cacheDirectory, pending, { recursive: true, errorOnExist: true, force: false });
       await (0, import_promises5.writeFile)(
-        (0, import_node_path21.join)(pending, ".alan-managed.json"),
+        (0, import_node_path22.join)(pending, ".alan-managed.json"),
         `${JSON.stringify(markerFor(entry), null, 2)}
 `,
         { encoding: "utf8", flag: "wx", mode: 384 }
@@ -77053,7 +76990,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     }
   }
   async requireReplaceable(entry) {
-    const destination = (0, import_node_path21.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
+    const destination = (0, import_node_path22.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
     if (!await pathExists2(destination)) return;
     const marker = await readMarker(destination);
     if (!marker) throw unmanagedPathConflict(entry.runtimeDirectory);
@@ -77070,8 +77007,8 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     if (!this.store.inspect().canRemoveManagedFiles) return failures;
     for (const [runtimeDirectory, recorded] of Object.entries(this.store.projections())) {
       if (desired[runtimeDirectory]) continue;
-      const destination = (0, import_node_path21.join)(this.managedSkillsDirectory, runtimeDirectory);
-      const compatibility = (0, import_node_path21.join)(this.compatibilitySkillsDirectory, runtimeDirectory);
+      const destination = (0, import_node_path22.join)(this.managedSkillsDirectory, runtimeDirectory);
+      const compatibility = (0, import_node_path22.join)(this.compatibilitySkillsDirectory, runtimeDirectory);
       const marker = await readMarker(destination);
       if (!await pathExists2(destination)) continue;
       if (marker && markerMatchesProjection(marker, recorded)) {
@@ -77102,7 +77039,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   }
   async ensureCompatibilityProjection(entry, canonicalDirectory) {
     await (0, import_promises5.mkdir)(this.compatibilitySkillsDirectory, { recursive: true, mode: 448 });
-    const destination = (0, import_node_path21.join)(this.compatibilitySkillsDirectory, entry.runtimeDirectory);
+    const destination = (0, import_node_path22.join)(this.compatibilitySkillsDirectory, entry.runtimeDirectory);
     if (await pathExists2(destination)) {
       if (await compatibilityProjectionMatches(destination, canonicalDirectory, entry)) return;
       throw unmanagedCompatibilityConflict(entry.runtimeDirectory);
@@ -77117,7 +77054,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     try {
       await (0, import_promises5.cp)(canonicalDirectory, pending, { recursive: true, errorOnExist: true, force: false });
       await (0, import_promises5.writeFile)(
-        (0, import_node_path21.join)(pending, ".alan-compatibility.json"),
+        (0, import_node_path22.join)(pending, ".alan-compatibility.json"),
         `${JSON.stringify({ ...markerFor(entry), canonicalDirectory }, null, 2)}
 `,
         { encoding: "utf8", flag: "wx", mode: 384 }
@@ -77142,14 +77079,14 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   }
   async withMachineLock(work) {
     await (0, import_promises5.mkdir)(this.skillsStateDirectory, { recursive: true, mode: 448 });
-    const lockDirectory = (0, import_node_path21.join)(this.skillsStateDirectory, "manager.lock");
+    const lockDirectory = (0, import_node_path22.join)(this.skillsStateDirectory, "manager.lock");
     const deadline = Date.now() + 3e4;
     while (true) {
       try {
         await (0, import_promises5.mkdir)(lockDirectory, { mode: 448 });
         try {
           await (0, import_promises5.writeFile)(
-            (0, import_node_path21.join)(lockDirectory, "owner.json"),
+            (0, import_node_path22.join)(lockDirectory, "owner.json"),
             `${JSON.stringify({ pid: process.pid, acquiredAt: (/* @__PURE__ */ new Date()).toISOString() })}
 `,
             { encoding: "utf8", flag: "wx", mode: 384 }
@@ -77199,7 +77136,7 @@ async function packageMatches(directory, expectedHash) {
 async function readMarker(directory) {
   try {
     const value2 = JSON.parse(
-      await (0, import_promises5.readFile)((0, import_node_path21.join)(directory, ".alan-managed.json"), "utf8")
+      await (0, import_promises5.readFile)((0, import_node_path22.join)(directory, ".alan-managed.json"), "utf8")
     );
     if (typeof value2 !== "object" || value2 === null || !("protocolVersion" in value2) || value2.protocolVersion !== SKILLS_PROTOCOL_VERSION || !("skillId" in value2) || typeof value2.skillId !== "string" || !("versionId" in value2) || typeof value2.versionId !== "string" || !("contentHash" in value2) || typeof value2.contentHash !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value2.contentHash)) {
       return null;
@@ -77213,7 +77150,7 @@ async function compatibilityProjectionMatches(destination, canonicalDirectory, e
   const metadata = await (0, import_promises5.lstat)(destination);
   if (metadata.isSymbolicLink()) {
     const target = await (0, import_promises5.readlink)(destination);
-    return (0, import_node_path21.resolve)((0, import_node_path21.dirname)(destination), target) === (0, import_node_path21.resolve)(canonicalDirectory);
+    return (0, import_node_path22.resolve)((0, import_node_path22.dirname)(destination), target) === (0, import_node_path22.resolve)(canonicalDirectory);
   }
   if (!metadata.isDirectory()) return false;
   const marker = await readCompatibilityMarker(destination);
@@ -77224,7 +77161,7 @@ async function removeCompatibilityProjection(destination, canonicalDirectory, pr
   const metadata = await (0, import_promises5.lstat)(destination);
   if (metadata.isSymbolicLink()) {
     const target = await (0, import_promises5.readlink)(destination);
-    if ((0, import_node_path21.resolve)((0, import_node_path21.dirname)(destination), target) !== (0, import_node_path21.resolve)(canonicalDirectory)) return false;
+    if ((0, import_node_path22.resolve)((0, import_node_path22.dirname)(destination), target) !== (0, import_node_path22.resolve)(canonicalDirectory)) return false;
     await (0, import_promises5.rm)(destination, { force: true });
     return true;
   }
@@ -77236,7 +77173,7 @@ async function removeCompatibilityProjection(destination, canonicalDirectory, pr
 async function readCompatibilityMarker(directory) {
   try {
     const value2 = JSON.parse(
-      await (0, import_promises5.readFile)((0, import_node_path21.join)(directory, ".alan-compatibility.json"), "utf8")
+      await (0, import_promises5.readFile)((0, import_node_path22.join)(directory, ".alan-compatibility.json"), "utf8")
     );
     if (value2.protocolVersion !== SKILLS_PROTOCOL_VERSION || typeof value2.skillId !== "string" || typeof value2.versionId !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value2.contentHash) || typeof value2.canonicalDirectory !== "string") {
       return null;
@@ -77276,7 +77213,7 @@ async function legacyFileMatches(directory, expectedHash) {
   try {
     const metadata = await (0, import_promises5.lstat)(directory);
     if (!metadata.isDirectory() || metadata.isSymbolicLink()) return false;
-    const content = await (0, import_promises5.readFile)((0, import_node_path21.join)(directory, "SKILL.md"));
+    const content = await (0, import_promises5.readFile)((0, import_node_path22.join)(directory, "SKILL.md"));
     return (0, import_node_crypto15.createHash)("sha256").update(content).digest("hex").slice(0, 16) === expectedHash;
   } catch {
     return false;
@@ -77284,7 +77221,7 @@ async function legacyFileMatches(directory, expectedHash) {
 }
 async function removeExactLegacySkill(directory, expectedHash) {
   if (!await legacyFileMatches(directory, expectedHash)) return;
-  await (0, import_promises5.rm)((0, import_node_path21.join)(directory, "SKILL.md"), { force: true });
+  await (0, import_promises5.rm)((0, import_node_path22.join)(directory, "SKILL.md"), { force: true });
   const remaining = await (0, import_promises5.readdir)(directory);
   if (remaining.length === 0) await (0, import_promises5.rm)(directory, { recursive: true, force: true });
 }
@@ -77444,13 +77381,13 @@ async function startDaemon(args) {
     getRuntimeToken: () => runtimeToken
   });
   const runtimeSkillManager = await RuntimeSkillManager.open({
-    homeDirectory: (0, import_node_os10.homedir)(),
+    homeDirectory: (0, import_node_os11.homedir)(),
     controlClient: skillControl
   });
   const runtimeSkillCoordinator = new RuntimeSkillCoordinator(
     runtimeSkillManager,
     skillControl,
-    (input2) => resolveSkillScanInput((0, import_node_os10.homedir)(), input2)
+    (input2) => resolveSkillScanInput((0, import_node_os11.homedir)(), input2)
   );
   const runSkillSync = (reason) => {
     const operation = reason === "startup" ? runtimeSkillCoordinator.runStartup() : reason === "interval" ? runtimeSkillCoordinator.runIncremental() : reason === "refresh" ? runtimeSkillCoordinator.runAudit() : runtimeSkillCoordinator.run();
@@ -77524,10 +77461,10 @@ async function startDaemon(args) {
     installationId
   });
   const recentLogs = [];
-  const daemonLogPath = (0, import_node_path22.join)((0, import_node_path22.dirname)(configPath), "logs", "daemon.log");
+  const daemonLogPath = (0, import_node_path23.join)((0, import_node_path23.dirname)(configPath), "logs", "daemon.log");
   const persistDaemonLog = (line) => {
     try {
-      (0, import_node_fs20.mkdirSync)((0, import_node_path22.dirname)(daemonLogPath), { recursive: true });
+      (0, import_node_fs20.mkdirSync)((0, import_node_path23.dirname)(daemonLogPath), { recursive: true });
       try {
         if ((0, import_node_fs20.statSync)(daemonLogPath).size > 5 * 1024 * 1024) {
           (0, import_node_fs20.renameSync)(daemonLogPath, `${daemonLogPath}.1`);
@@ -77659,7 +77596,7 @@ async function startDaemon(args) {
   };
   for (const relocation of stored.workspaceRelocations ?? []) {
     if (relocation?.conversationId && relocation.runId && relocation.previousPath && relocation.canonicalPath) {
-      workspaceRelocations.set((0, import_node_path22.resolve)(relocation.previousPath), relocation);
+      workspaceRelocations.set((0, import_node_path23.resolve)(relocation.previousPath), relocation);
     }
   }
   if (stored.localApiPort !== localApiPort || stored.localApiToken !== localApiToken || stored.localServiceId !== localServiceId || stored.localServiceSecret !== localServiceSecret || stored.eventSpoolKey !== eventSpoolKey || stored.daemonEpoch !== daemonEpoch || stored.installationId !== installationId) {
@@ -78367,7 +78304,7 @@ async function setupDaemon(args) {
   const teamId = argValue(args, "--team") ?? process.env.ALAN_TEAM_ID;
   const setupToken = argValue(args, "--setup-token") ?? process.env.ALAN_RUNTIME_SETUP_TOKEN;
   const token = argValue(args, "--token") ?? process.env.ALAN_SETUP_TOKEN;
-  const displayName = argValue(args, "--name") ?? (0, import_node_os11.hostname)();
+  const displayName = argValue(args, "--name") ?? (0, import_node_os12.hostname)();
   const scope = argValue(args, "--scope") ?? process.env.ALAN_RUNTIME_SCOPE ?? (setupToken ? "team" : "user");
   const installationId = argValue(args, "--installation-id") ?? previousConfig.installationId ?? (0, import_node_crypto17.randomUUID)();
   if (scope !== "team" && scope !== "user") {
@@ -78390,7 +78327,7 @@ async function setupDaemon(args) {
       ...teamId ? { teamId } : {},
       ...setupToken ? { setupToken, registrationAttemptId } : {},
       displayName,
-      hostname: (0, import_node_os11.hostname)(),
+      hostname: (0, import_node_os12.hostname)(),
       runtimeKind: "machine",
       managementKind: "user_managed",
       hostKind: "daemon",
@@ -78474,7 +78411,7 @@ async function loginWithDeviceCode(args) {
     }
     const previousConfig = readConfigForRegistration();
     const { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(args);
-    const displayName = argValue(args, "--name") ?? (0, import_node_os11.hostname)();
+    const displayName = argValue(args, "--name") ?? (0, import_node_os12.hostname)();
     const maxPolls = Number.parseInt(argValue(args, "--max-polls") ?? "300", 10);
     const resumed = readPendingDeviceAuthorization(apiUrl);
     const installationId = resumed?.installationId ?? previousConfig.installationId ?? (0, import_node_crypto17.randomUUID)();
@@ -78486,7 +78423,7 @@ async function loginWithDeviceCode(args) {
         headers: { "content-type": "application/json" },
         body: JSON.stringify({
           displayName,
-          hostname: (0, import_node_os11.hostname)(),
+          hostname: (0, import_node_os12.hostname)(),
           capabilities: discoverCapabilities(),
           metadata: {
             ...await collectRuntimeMetadataWithProviderLimits(),
@@ -78910,8 +78847,8 @@ async function printDoctor(args = []) {
 // src/mcp-config-adapters.ts
 var import_node_crypto18 = require("crypto");
 var import_node_fs21 = require("fs");
-var import_node_os12 = require("os");
-var import_node_path23 = require("path");
+var import_node_os13 = require("os");
+var import_node_path24 = require("path");
 var log = {
   info: (...args) => console.info("[mcp-config-adapters]", ...args),
   warn: (...args) => console.warn("[mcp-config-adapters]", ...args),
@@ -78920,7 +78857,7 @@ var log = {
 };
 var homeDirectoryOverride;
 function homeDirectory() {
-  return homeDirectoryOverride ?? (0, import_node_os12.homedir)();
+  return homeDirectoryOverride ?? (0, import_node_os13.homedir)();
 }
 var MalformedToolConfigError = class extends Error {
 };
@@ -78939,7 +78876,7 @@ function readFileOr(path2) {
   return (0, import_node_fs21.existsSync)(path2) ? (0, import_node_fs21.readFileSync)(path2, "utf-8") : null;
 }
 function acquireConfigLock2(path2) {
-  (0, import_node_fs21.mkdirSync)((0, import_node_path23.dirname)(path2), { recursive: true });
+  (0, import_node_fs21.mkdirSync)((0, import_node_path24.dirname)(path2), { recursive: true });
   const lockPath = `${path2}.alan-lock`;
   const startedAt = Date.now();
   while (true) {
@@ -78965,7 +78902,7 @@ function acquireConfigLock2(path2) {
   }
 }
 function writeFileSafe2(path2, content) {
-  (0, import_node_fs21.mkdirSync)((0, import_node_path23.dirname)(path2), { recursive: true });
+  (0, import_node_fs21.mkdirSync)((0, import_node_path24.dirname)(path2), { recursive: true });
   const pendingPath = `${path2}.alan-pending-${process.pid}-${(0, import_node_crypto18.randomBytes)(6).toString("hex")}`;
   try {
     (0, import_node_fs21.writeFileSync)(pendingPath, content, { encoding: "utf8", mode: 384, flag: "wx" });
@@ -78983,7 +78920,7 @@ function saveMalformedBackup2(path2, content) {
 var claudeAdapter = {
   cli: "Claude Code",
   get configPath() {
-    return (0, import_node_path23.join)(homeDirectory(), ".claude.json");
+    return (0, import_node_path24.join)(homeDirectory(), ".claude.json");
   },
   get guardDir() {
     return homeDirectory();
@@ -79016,10 +78953,10 @@ var claudeAdapter = {
 var codexAdapter = {
   cli: "Codex",
   get configPath() {
-    return (0, import_node_path23.join)(homeDirectory(), ".codex", "config.toml");
+    return (0, import_node_path24.join)(homeDirectory(), ".codex", "config.toml");
   },
   get guardDir() {
-    return (0, import_node_path23.join)(homeDirectory(), ".codex");
+    return (0, import_node_path24.join)(homeDirectory(), ".codex");
   },
   merge(existing, servers) {
     let config2 = {};
@@ -79062,10 +78999,10 @@ var codexAdapter = {
 var cursorAdapter = {
   cli: "Cursor",
   get configPath() {
-    return (0, import_node_path23.join)(homeDirectory(), ".cursor", "mcp.json");
+    return (0, import_node_path24.join)(homeDirectory(), ".cursor", "mcp.json");
   },
   get guardDir() {
-    return (0, import_node_path23.join)(homeDirectory(), ".cursor");
+    return (0, import_node_path24.join)(homeDirectory(), ".cursor");
   },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
@@ -79096,10 +79033,10 @@ function createAntigravityAdapter() {
   return {
     cli: "Antigravity CLI",
     get configPath() {
-      return (0, import_node_path23.join)(homeDirectory(), ".gemini", "config", "mcp_config.json");
+      return (0, import_node_path24.join)(homeDirectory(), ".gemini", "config", "mcp_config.json");
     },
     get guardDir() {
-      return (0, import_node_path23.join)(homeDirectory(), ".gemini", "config");
+      return (0, import_node_path24.join)(homeDirectory(), ".gemini", "config");
     },
     merge(existing, servers) {
       const config2 = parseJsonSafe2(existing);
@@ -79131,10 +79068,10 @@ var antigravityAdapter = createAntigravityAdapter();
 var kimiAdapter = {
   cli: "Kimi CLI",
   get configPath() {
-    return (0, import_node_path23.join)(homeDirectory(), ".kimi", "mcp.json");
+    return (0, import_node_path24.join)(homeDirectory(), ".kimi", "mcp.json");
   },
   get guardDir() {
-    return (0, import_node_path23.join)(homeDirectory(), ".kimi");
+    return (0, import_node_path24.join)(homeDirectory(), ".kimi");
   },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
@@ -79164,10 +79101,10 @@ var kimiAdapter = {
 var opencodeAdapter = {
   cli: "OpenCode",
   get configPath() {
-    return (0, import_node_path23.join)(homeDirectory(), ".config", "opencode", "opencode.json");
+    return (0, import_node_path24.join)(homeDirectory(), ".config", "opencode", "opencode.json");
   },
   get guardDir() {
-    return (0, import_node_path23.join)(homeDirectory(), ".config", "opencode");
+    return (0, import_node_path24.join)(homeDirectory(), ".config", "opencode");
   },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
@@ -79197,10 +79134,10 @@ var opencodeAdapter = {
 var factoryAdapter = {
   cli: "Factory Droid",
   get configPath() {
-    return (0, import_node_path23.join)(homeDirectory(), ".factory", "mcp.json");
+    return (0, import_node_path24.join)(homeDirectory(), ".factory", "mcp.json");
   },
   get guardDir() {
-    return (0, import_node_path23.join)(homeDirectory(), ".factory");
+    return (0, import_node_path24.join)(homeDirectory(), ".factory");
   },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
@@ -79237,10 +79174,10 @@ var factoryAdapter = {
 var ampAdapter = {
   cli: "Amp",
   get configPath() {
-    return (0, import_node_path23.join)(homeDirectory(), ".config", "amp", "settings.json");
+    return (0, import_node_path24.join)(homeDirectory(), ".config", "amp", "settings.json");
   },
   get guardDir() {
-    return (0, import_node_path23.join)(homeDirectory(), ".config", "amp");
+    return (0, import_node_path24.join)(homeDirectory(), ".config", "amp");
   },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
@@ -79665,8 +79602,8 @@ var McpSyncService = class {
 
 // src/native-hook-config.ts
 var import_node_fs22 = require("fs");
-var import_node_os13 = require("os");
-var import_node_path24 = require("path");
+var import_node_os14 = require("os");
+var import_node_path25 = require("path");
 var ALAN_HOOK_MARKER = "# alan-native-session-hook";
 var ALAN_KIMI_HOOKS_START = "# alan-native-session-hooks:start";
 var ALAN_KIMI_HOOKS_END = "# alan-native-session-hooks:end";
@@ -79759,7 +79696,7 @@ function nativeHookCommand(input2) {
   if (environment.length === 0) {
     return { type: "command", command: input2.nodeExecutable, args, timeout: 5 };
   }
-  if ((input2.platform ?? (0, import_node_os13.platform)()) === "win32") {
+  if ((input2.platform ?? (0, import_node_os14.platform)()) === "win32") {
     const environmentPrefix2 = environment.map(([key, value2]) => `$env:${key}=${powershellQuote(value2)}`).join("; ");
     const command2 = [input2.nodeExecutable, ...args].map(powershellQuote).join(" ");
     return {
@@ -79804,11 +79741,11 @@ function resolveRuntime(input2 = {}) {
   }
   return {
     configPath,
-    homeDir: input2.homeDir ?? (0, import_node_os13.homedir)(),
+    homeDir: input2.homeDir ?? (0, import_node_os14.homedir)(),
     nodeExecutable: input2.nodeExecutable ?? process.execPath,
     cliEntry,
     environment: input2.environment,
-    platform: input2.platform ?? (0, import_node_os13.platform)()
+    platform: input2.platform ?? (0, import_node_os14.platform)()
   };
 }
 function readSettings(path2, providerLabel) {
@@ -79835,7 +79772,7 @@ function writeSettings(path2, settings) {
   const serialized = `${JSON.stringify(settings, null, 2)}
 `;
   if ((0, import_node_fs22.existsSync)(path2) && (0, import_node_fs22.readFileSync)(path2, "utf8") === serialized) return false;
-  (0, import_node_fs22.mkdirSync)((0, import_node_path24.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs22.mkdirSync)((0, import_node_path25.dirname)(path2), { recursive: true, mode: 448 });
   const temporary = `${path2}.${process.pid}.tmp`;
   (0, import_node_fs22.writeFileSync)(temporary, serialized, { mode: 384 });
   (0, import_node_fs22.renameSync)(temporary, path2);
@@ -79843,7 +79780,7 @@ function writeSettings(path2, settings) {
 }
 function writeTextFile(path2, content) {
   if ((0, import_node_fs22.existsSync)(path2) && (0, import_node_fs22.readFileSync)(path2, "utf8") === content) return false;
-  (0, import_node_fs22.mkdirSync)((0, import_node_path24.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs22.mkdirSync)((0, import_node_path25.dirname)(path2), { recursive: true, mode: 448 });
   const temporary = `${path2}.${process.pid}.tmp`;
   (0, import_node_fs22.writeFileSync)(temporary, content, { mode: 384 });
   (0, import_node_fs22.renameSync)(temporary, path2);
@@ -79887,7 +79824,7 @@ function removeNestedCommandHooks(path2, providerLabel) {
 function reconcileClaudeNativeHooks(input2 = {}) {
   const runtime = resolveRuntime(input2);
   return reconcileNestedCommandHooks({
-    path: (0, import_node_path24.join)(runtime.homeDir, ".claude", "settings.json"),
+    path: (0, import_node_path25.join)(runtime.homeDir, ".claude", "settings.json"),
     providerLabel: "Claude",
     events: CLAUDE_HOOK_EVENTS,
     command: (event) => ({
@@ -79899,13 +79836,13 @@ function reconcileClaudeNativeHooks(input2 = {}) {
     })
   });
 }
-function removeClaudeNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
-  return removeNestedCommandHooks((0, import_node_path24.join)(homeDir, ".claude", "settings.json"), "Claude");
+function removeClaudeNativeHooks(homeDir = (0, import_node_os14.homedir)()) {
+  return removeNestedCommandHooks((0, import_node_path25.join)(homeDir, ".claude", "settings.json"), "Claude");
 }
 function reconcileCodexNativeHooks(input2 = {}) {
   const runtime = resolveRuntime(input2);
   return reconcileNestedCommandHooks({
-    path: (0, import_node_path24.join)(runtime.homeDir, ".codex", "hooks.json"),
+    path: (0, import_node_path25.join)(runtime.homeDir, ".codex", "hooks.json"),
     providerLabel: "Codex",
     events: CODEX_HOOK_EVENTS,
     command: (event) => ({
@@ -79916,12 +79853,12 @@ function reconcileCodexNativeHooks(input2 = {}) {
     })
   });
 }
-function removeCodexNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
-  return removeNestedCommandHooks((0, import_node_path24.join)(homeDir, ".codex", "hooks.json"), "Codex");
+function removeCodexNativeHooks(homeDir = (0, import_node_os14.homedir)()) {
+  return removeNestedCommandHooks((0, import_node_path25.join)(homeDir, ".codex", "hooks.json"), "Codex");
 }
 function reconcileCopilotNativeHooks(input2 = {}) {
   const runtime = resolveRuntime(input2);
-  const path2 = (0, import_node_path24.join)(runtime.homeDir, ".copilot", "hooks", "alan-native-session.json");
+  const path2 = (0, import_node_path25.join)(runtime.homeDir, ".copilot", "hooks", "alan-native-session.json");
   if ((0, import_node_fs22.existsSync)(path2) && !(0, import_node_fs22.readFileSync)(path2, "utf8").includes(ALAN_HOOK_MARKER)) {
     throw new Error(`Refusing to overwrite non-Alan Copilot hook configuration at ${path2}`);
   }
@@ -79940,8 +79877,8 @@ function reconcileCopilotNativeHooks(input2 = {}) {
   );
   return writeSettings(path2, { version: 1, hooks });
 }
-function removeCopilotNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
-  const path2 = (0, import_node_path24.join)(homeDir, ".copilot", "hooks", "alan-native-session.json");
+function removeCopilotNativeHooks(homeDir = (0, import_node_os14.homedir)()) {
+  const path2 = (0, import_node_path25.join)(homeDir, ".copilot", "hooks", "alan-native-session.json");
   if (!(0, import_node_fs22.existsSync)(path2)) return false;
   if (!(0, import_node_fs22.readFileSync)(path2, "utf8").includes(ALAN_HOOK_MARKER)) return false;
   (0, import_node_fs22.rmSync)(path2);
@@ -79949,7 +79886,7 @@ function removeCopilotNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
 }
 function reconcileCursorNativeHooks(input2 = {}) {
   const runtime = resolveRuntime(input2);
-  const path2 = (0, import_node_path24.join)(runtime.homeDir, ".cursor", "hooks.json");
+  const path2 = (0, import_node_path25.join)(runtime.homeDir, ".cursor", "hooks.json");
   const settings = readSettings(path2, "Cursor");
   const currentHooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks) ? settings.hooks : {};
   const hooks = { ...currentHooks };
@@ -79965,8 +79902,8 @@ function reconcileCursorNativeHooks(input2 = {}) {
   }
   return writeSettings(path2, { ...settings, version: settings.version ?? 1, hooks });
 }
-function removeCursorNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
-  const path2 = (0, import_node_path24.join)(homeDir, ".cursor", "hooks.json");
+function removeCursorNativeHooks(homeDir = (0, import_node_os14.homedir)()) {
+  const path2 = (0, import_node_path25.join)(homeDir, ".cursor", "hooks.json");
   if (!(0, import_node_fs22.existsSync)(path2)) return false;
   const settings = readSettings(path2, "Cursor");
   if (!settings.hooks || typeof settings.hooks !== "object" || Array.isArray(settings.hooks)) {
@@ -79996,15 +79933,15 @@ ${ALAN_KIMI_HOOKS_END}`;
 }
 function reconcileKimiNativeHooks(input2 = {}) {
   const runtime = resolveRuntime(input2);
-  const path2 = (0, import_node_path24.join)(runtime.homeDir, ".kimi-code", "config.toml");
+  const path2 = (0, import_node_path25.join)(runtime.homeDir, ".kimi-code", "config.toml");
   const current = (0, import_node_fs22.existsSync)(path2) ? (0, import_node_fs22.readFileSync)(path2, "utf8") : "";
   const userContent = withoutMarkedSection(current, ALAN_KIMI_HOOKS_START, ALAN_KIMI_HOOKS_END);
   const content = `${userContent.trimEnd()}${userContent.trim() ? "\n\n" : ""}${kimiHookSection(runtime)}
 `;
   return writeTextFile(path2, content);
 }
-function removeKimiNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
-  const path2 = (0, import_node_path24.join)(homeDir, ".kimi-code", "config.toml");
+function removeKimiNativeHooks(homeDir = (0, import_node_os14.homedir)()) {
+  const path2 = (0, import_node_path25.join)(homeDir, ".kimi-code", "config.toml");
   if (!(0, import_node_fs22.existsSync)(path2)) return false;
   const current = (0, import_node_fs22.readFileSync)(path2, "utf8");
   const content = withoutMarkedSection(current, ALAN_KIMI_HOOKS_START, ALAN_KIMI_HOOKS_END);
@@ -80014,7 +79951,7 @@ function removeKimiNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
 }
 function reconcileGrokNativeHooks(input2 = {}) {
   const runtime = resolveRuntime(input2);
-  const path2 = (0, import_node_path24.join)(runtime.homeDir, ".grok", "hooks", "alan-native-session.json");
+  const path2 = (0, import_node_path25.join)(runtime.homeDir, ".grok", "hooks", "alan-native-session.json");
   if ((0, import_node_fs22.existsSync)(path2) && !(0, import_node_fs22.readFileSync)(path2, "utf8").includes(ALAN_HOOK_MARKER)) {
     throw new Error(`Refusing to overwrite non-Alan Grok hook configuration at ${path2}`);
   }
@@ -80029,8 +79966,8 @@ function reconcileGrokNativeHooks(input2 = {}) {
     })
   });
 }
-function removeGrokNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
-  const path2 = (0, import_node_path24.join)(homeDir, ".grok", "hooks", "alan-native-session.json");
+function removeGrokNativeHooks(homeDir = (0, import_node_os14.homedir)()) {
+  const path2 = (0, import_node_path25.join)(homeDir, ".grok", "hooks", "alan-native-session.json");
   if (!(0, import_node_fs22.existsSync)(path2)) return false;
   if (!(0, import_node_fs22.readFileSync)(path2, "utf8").includes(ALAN_HOOK_MARKER)) return false;
   (0, import_node_fs22.rmSync)(path2);
@@ -80121,20 +80058,20 @@ export const AlanNativeSessionPlugin = async ({ directory }) => {
 }
 function reconcileOpencodeNativePlugin(input2 = {}) {
   const runtime = resolveRuntime(input2);
-  const path2 = (0, import_node_path24.join)(runtime.homeDir, ".config", "opencode", "plugins", "alan-native-session.js");
+  const path2 = (0, import_node_path25.join)(runtime.homeDir, ".config", "opencode", "plugins", "alan-native-session.js");
   if ((0, import_node_fs22.existsSync)(path2) && !(0, import_node_fs22.readFileSync)(path2, "utf8").includes(ALAN_OPENCODE_PLUGIN_MARKER)) {
     throw new Error(`Refusing to overwrite non-Alan OpenCode plugin at ${path2}`);
   }
   const source = opencodePluginSource(runtime);
   if ((0, import_node_fs22.existsSync)(path2) && (0, import_node_fs22.readFileSync)(path2, "utf8") === source) return false;
-  (0, import_node_fs22.mkdirSync)((0, import_node_path24.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs22.mkdirSync)((0, import_node_path25.dirname)(path2), { recursive: true, mode: 448 });
   const temporary = `${path2}.${process.pid}.tmp`;
   (0, import_node_fs22.writeFileSync)(temporary, source, { mode: 384 });
   (0, import_node_fs22.renameSync)(temporary, path2);
   return true;
 }
-function removeOpencodeNativePlugin(homeDir = (0, import_node_os13.homedir)()) {
-  const path2 = (0, import_node_path24.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js");
+function removeOpencodeNativePlugin(homeDir = (0, import_node_os14.homedir)()) {
+  const path2 = (0, import_node_path25.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js");
   if (!(0, import_node_fs22.existsSync)(path2)) return false;
   if (!(0, import_node_fs22.readFileSync)(path2, "utf8").includes(ALAN_OPENCODE_PLUGIN_MARKER)) return false;
   (0, import_node_fs22.rmSync)(path2);
@@ -80148,32 +80085,32 @@ function configFileContainsMarker(path2, marker) {
     return false;
   }
 }
-function inspectNativeHooksConfigured(providerKind, homeDir = (0, import_node_os13.homedir)()) {
+function inspectNativeHooksConfigured(providerKind, homeDir = (0, import_node_os14.homedir)()) {
   switch (providerKind) {
     case "claude_cli":
-      return configFileContainsMarker((0, import_node_path24.join)(homeDir, ".claude", "settings.json"), ALAN_HOOK_MARKER);
+      return configFileContainsMarker((0, import_node_path25.join)(homeDir, ".claude", "settings.json"), ALAN_HOOK_MARKER);
     case "codex_app_server":
-      return configFileContainsMarker((0, import_node_path24.join)(homeDir, ".codex", "hooks.json"), ALAN_HOOK_MARKER);
+      return configFileContainsMarker((0, import_node_path25.join)(homeDir, ".codex", "hooks.json"), ALAN_HOOK_MARKER);
     case "copilot_cli":
       return configFileContainsMarker(
-        (0, import_node_path24.join)(homeDir, ".copilot", "hooks", "alan-native-session.json"),
+        (0, import_node_path25.join)(homeDir, ".copilot", "hooks", "alan-native-session.json"),
         ALAN_HOOK_MARKER
       );
     case "cursor_agent_cli":
-      return configFileContainsMarker((0, import_node_path24.join)(homeDir, ".cursor", "hooks.json"), ALAN_HOOK_MARKER);
+      return configFileContainsMarker((0, import_node_path25.join)(homeDir, ".cursor", "hooks.json"), ALAN_HOOK_MARKER);
     case "kimi_cli":
       return configFileContainsMarker(
-        (0, import_node_path24.join)(homeDir, ".kimi-code", "config.toml"),
+        (0, import_node_path25.join)(homeDir, ".kimi-code", "config.toml"),
         ALAN_KIMI_HOOKS_START
       );
     case "grok_cli":
       return configFileContainsMarker(
-        (0, import_node_path24.join)(homeDir, ".grok", "hooks", "alan-native-session.json"),
+        (0, import_node_path25.join)(homeDir, ".grok", "hooks", "alan-native-session.json"),
         ALAN_HOOK_MARKER
       );
     case "opencode_cli":
       return configFileContainsMarker(
-        (0, import_node_path24.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js"),
+        (0, import_node_path25.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js"),
         ALAN_OPENCODE_PLUGIN_MARKER
       );
     default:
@@ -80337,8 +80274,8 @@ function omitUndefined(record2) {
 // src/native-hook-command.ts
 var import_node_crypto19 = require("crypto");
 var import_node_fs23 = require("fs");
-var import_node_os14 = require("os");
-var import_node_path25 = require("path");
+var import_node_os15 = require("os");
+var import_node_path26 = require("path");
 
 // src/native-session.ts
 var NATIVE_SESSION_PROVIDER_CAPABILITIES = [
@@ -80572,19 +80509,19 @@ function nonNegativeIntegerField(payload, ...names) {
   return void 0;
 }
 function resolveCodexSessionIdFromTranscriptPath(transcriptPath) {
-  const fileName = (0, import_node_path25.basename)(transcriptPath);
+  const fileName = (0, import_node_path26.basename)(transcriptPath);
   const match = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i.exec(
     fileName
   );
   return match?.[1];
 }
-function resolveKimiTranscriptPath(externalSessionId, kimiHomeDir = process.env.KIMI_CODE_HOME?.trim() || (0, import_node_path25.join)((0, import_node_os14.homedir)(), ".kimi-code")) {
-  if ((0, import_node_path25.basename)(externalSessionId) !== externalSessionId) return void 0;
-  const sessionsDir = (0, import_node_path25.join)(kimiHomeDir, "sessions");
+function resolveKimiTranscriptPath(externalSessionId, kimiHomeDir = process.env.KIMI_CODE_HOME?.trim() || (0, import_node_path26.join)((0, import_node_os15.homedir)(), ".kimi-code")) {
+  if ((0, import_node_path26.basename)(externalSessionId) !== externalSessionId) return void 0;
+  const sessionsDir = (0, import_node_path26.join)(kimiHomeDir, "sessions");
   if (!(0, import_node_fs23.existsSync)(sessionsDir)) return void 0;
   for (const workspace of (0, import_node_fs23.readdirSync)(sessionsDir, { withFileTypes: true })) {
     if (!workspace.isDirectory()) continue;
-    const transcriptPath = (0, import_node_path25.join)(
+    const transcriptPath = (0, import_node_path26.join)(
       sessionsDir,
       workspace.name,
       externalSessionId,
@@ -80669,8 +80606,8 @@ function parseNativeHookEnvelope(input2) {
     observedAt: (input2.now ?? /* @__PURE__ */ new Date()).toISOString(),
     externalSessionId,
     ...(eventType === "subagent_start" || eventType === "subagent_end") && parentSessionId ? { parentExternalSessionId: parentSessionId } : {},
-    ...cwd ? { cwd: (0, import_node_path25.resolve)(cwd) } : {},
-    ...transcriptPath ? { transcriptPath: (0, import_node_path25.resolve)(transcriptPath) } : {},
+    ...cwd ? { cwd: (0, import_node_path26.resolve)(cwd) } : {},
+    ...transcriptPath ? { transcriptPath: (0, import_node_path26.resolve)(transcriptPath) } : {},
     ...cursor ? { sourceCursor: cursor } : {},
     providerPayload
   };
@@ -80797,7 +80734,7 @@ function collectNativeIntegrationStatus(args = []) {
   bindConfigPath(args);
   const config2 = readConfig();
   const env = getDaemonCliEnvironment();
-  const homeDir = (0, import_node_os14.homedir)();
+  const homeDir = (0, import_node_os15.homedir)();
   return NATIVE_SESSION_PROVIDER_CAPABILITIES.map((capability) => ({
     provider: capability.providerKind,
     command: capability.command,
@@ -80826,7 +80763,7 @@ function decodeResumeFallbackContext(encoded) {
 }
 
 // src/sandbox.ts
-var import_node_os15 = require("os");
+var import_node_os16 = require("os");
 
 // src/execution-activity-tracker.ts
 var ExecutionActivityTracker = class {
@@ -82123,7 +82060,7 @@ async function runSandbox(config2) {
   }
   const presenter = new WebPresenter(wsClient, config2.sessionId, config2.projectPath);
   presenter.setSuppressSessionLifecycle(true);
-  const runtimeSkillManager = await RuntimeSkillManager.open({ homeDirectory: (0, import_node_os15.homedir)() });
+  const runtimeSkillManager = await RuntimeSkillManager.open({ homeDirectory: (0, import_node_os16.homedir)() });
   let lastProviderSessionId = config2.providerSessionId;
   let resumeFallbackContext = config2.resumeFallbackContext;
   let activeBackendKind = config2.backendKind || "claude_cli";
@@ -82423,8 +82360,8 @@ async function runSandbox(config2) {
 // src/service-manager.ts
 var import_node_child_process9 = require("child_process");
 var import_node_fs25 = require("fs");
-var import_node_os16 = require("os");
-var import_node_path26 = require("path");
+var import_node_os17 = require("os");
+var import_node_path27 = require("path");
 var SERVICE_LABEL = "ai.tryalan.agent";
 var SYSTEMD_UNIT = "alan-agent.service";
 var WINDOWS_TASK = "Alan Agent";
@@ -82444,8 +82381,8 @@ function buildDaemonServicePlan(input2) {
     if (userId === void 0) throw new Error("Cannot determine the current macOS user ID");
     const domain2 = `gui/${userId}`;
     const serviceTarget = `${domain2}/${SERVICE_LABEL}`;
-    const manifestPath = (0, import_node_path26.join)(input2.homeDir, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
-    const logDir = (0, import_node_path26.join)(input2.homeDir, ".alan", "agent", "logs");
+    const manifestPath = (0, import_node_path27.join)(input2.homeDir, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+    const logDir = (0, import_node_path27.join)(input2.homeDir, ".alan", "agent", "logs");
     const programArguments = daemonArgs.map((arg) => `    <string>${xml(arg)}</string>`).join("\n");
     const environmentEntries = Object.entries(input2.environment ?? {}).map(([key, value2]) => `    <key>${xml(key)}</key>
     <string>${xml(value2)}</string>`).join("\n");
@@ -82474,9 +82411,9 @@ ${environmentBlock}  <key>RunAtLoad</key>
   <key>ThrottleInterval</key>
   <integer>5</integer>
   <key>StandardOutPath</key>
-  <string>${xml((0, import_node_path26.join)(logDir, "daemon.log"))}</string>
+  <string>${xml((0, import_node_path27.join)(logDir, "daemon.log"))}</string>
   <key>StandardErrorPath</key>
-  <string>${xml((0, import_node_path26.join)(logDir, "daemon-error.log"))}</string>
+  <string>${xml((0, import_node_path27.join)(logDir, "daemon-error.log"))}</string>
 </dict>
 </plist>
 `;
@@ -82515,7 +82452,7 @@ ${environmentBlock}  <key>RunAtLoad</key>
     };
   }
   if (input2.platform === "linux") {
-    const manifestPath = (0, import_node_path26.join)(input2.homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
+    const manifestPath = (0, import_node_path27.join)(input2.homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
     const environmentLines = Object.entries(input2.environment ?? {}).map(([key, value2]) => `Environment=${systemdArg(`${key}=${value2}`)}`).join("\n");
     const manifest = `[Unit]
 Description=Alan local agent daemon
@@ -82616,7 +82553,7 @@ WantedBy=default.target
   };
 }
 function currentServicePlan(args, runtime) {
-  const currentPlatform = (0, import_node_os16.platform)();
+  const currentPlatform = (0, import_node_os17.platform)();
   if (currentPlatform !== "darwin" && currentPlatform !== "linux" && currentPlatform !== "win32") {
     throw new Error(`Daemon service installation is not supported on ${currentPlatform}`);
   }
@@ -82625,15 +82562,15 @@ function currentServicePlan(args, runtime) {
   if (!cliEntry) throw new Error("Cannot determine the alan-agent executable path");
   return buildDaemonServicePlan({
     platform: currentPlatform,
-    homeDir: (0, import_node_os16.homedir)(),
+    homeDir: (0, import_node_os17.homedir)(),
     nodeExecutable: runtime?.executable ?? process.execPath,
-    cliEntry: (0, import_node_path26.resolve)(cliEntry),
+    cliEntry: (0, import_node_path27.resolve)(cliEntry),
     profile,
     environment: runtime?.environment
   });
 }
 function writeManifest(path2, contents) {
-  (0, import_node_fs25.mkdirSync)((0, import_node_path26.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs25.mkdirSync)((0, import_node_path27.dirname)(path2), { recursive: true, mode: 448 });
   const pendingPath = `${path2}.pending-${process.pid}`;
   try {
     (0, import_node_fs25.writeFileSync)(pendingPath, contents, { mode: 384 });
@@ -82662,8 +82599,8 @@ function installDaemonService(args = [], runtime) {
   }
   const plan = currentServicePlan(args, runtime);
   if (plan.manifestPath && plan.manifest) {
-    if ((0, import_node_os16.platform)() === "darwin") {
-      (0, import_node_fs25.mkdirSync)((0, import_node_path26.join)((0, import_node_os16.homedir)(), ".alan", "agent", "logs"), { recursive: true, mode: 448 });
+    if ((0, import_node_os17.platform)() === "darwin") {
+      (0, import_node_fs25.mkdirSync)((0, import_node_path27.join)((0, import_node_os17.homedir)(), ".alan", "agent", "logs"), { recursive: true, mode: 448 });
     }
     writeManifest(plan.manifestPath, plan.manifest);
   }
@@ -82685,11 +82622,11 @@ function printDaemonServiceStatus(args = []) {
 
 // src/skills/skill-cli.ts
 var import_promises6 = require("fs/promises");
-var import_node_os17 = require("os");
-var import_node_path27 = require("path");
+var import_node_os18 = require("os");
+var import_node_path28 = require("path");
 async function runSkillsCommand(args) {
   const [subcommand, ...options] = args;
-  const homeDirectory2 = option(options, "--home") ?? (0, import_node_os17.homedir)();
+  const homeDirectory2 = option(options, "--home") ?? (0, import_node_os18.homedir)();
   const manager = await RuntimeSkillManager.open({ homeDirectory: homeDirectory2 });
   if (subcommand === "scan") {
     const inputPath = option(options, "--input");
@@ -82730,7 +82667,7 @@ async function defaultScanInput(homeDirectory2) {
   });
 }
 async function readProtectedJson(path2) {
-  const absolutePath = (0, import_node_path27.resolve)(path2);
+  const absolutePath = (0, import_node_path28.resolve)(path2);
   const stat2 = await (0, import_promises6.lstat)(absolutePath);
   if (!stat2.isFile()) throw new Error(`Skill input is not a regular file: ${absolutePath}`);
   if (process.platform !== "win32" && (stat2.mode & 63) !== 0) {