@aiden-ade/sandbox-agent 0.1.79 → 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.79";
+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,172 +15314,12 @@ 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");
 var import_node_path2 = require("path");
-function resolveAlanDefaultWorkspacePath(homeDirectory = (0, import_node_os2.homedir)()) {
-  return (0, import_node_path2.join)(homeDirectory, ".alan", "workspace");
+function resolveAlanDefaultWorkspacePath(homeDirectory2 = (0, import_node_os2.homedir)()) {
+  return (0, import_node_path2.join)(homeDirectory2, ".alan", "workspace");
 }
 
 // src/local-workspace-migration.ts
@@ -35665,6 +35407,22 @@ var import_node_os4 = require("os");
 var import_node_path5 = require("path");
 var DEFAULT_AGENT_DIR = (0, import_node_path5.join)((0, import_node_os4.homedir)(), ".alan", "agent");
 var LEGACY_AGENT_DIR = (0, import_node_path5.join)((0, import_node_os4.homedir)(), ".aiden", "agent");
+function configuredConfigPathFromEnvironment() {
+  const explicit = process.env.ALAN_AGENT_CONFIG_PATH?.trim() || process.env.ALAN_AGENT_CONFIG?.trim();
+  return explicit || void 0;
+}
+function resolveIsolatedAgentBaseDir(profile) {
+  switch (profile) {
+    case "local":
+      return (0, import_node_path5.join)((0, import_node_os4.homedir)(), ".alan-dev", "agent");
+    case "staging":
+      return (0, import_node_path5.join)((0, import_node_os4.homedir)(), ".alan-staging", "agent");
+    case "custom":
+      return (0, import_node_path5.join)((0, import_node_os4.homedir)(), ".alan-prod", "agent");
+    default:
+      return null;
+  }
+}
 var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Map([
   ["apiUrl", "string"],
   ["wsUrl", "string"],
@@ -35742,9 +35500,13 @@ function resolveAgentConfigPath(input2) {
   const profile = normalizeAgentEndpointProfile(
     typeof input2?.profile === "string" ? input2.profile : input2?.profile ?? null
   ) ?? "production";
-  const baseDir = input2?.baseDir ?? DEFAULT_AGENT_DIR;
-  if (input2?.baseDir === void 0) migrateLegacyAgentConfig({ profile });
-  return (0, import_node_path5.join)(baseDir, resolveAgentConfigFileName(profile));
+  if (input2?.baseDir !== void 0) {
+    return (0, import_node_path5.join)(input2.baseDir, resolveAgentConfigFileName(profile));
+  }
+  const isolatedBaseDir = profile === "production" ? null : resolveIsolatedAgentBaseDir(profile);
+  if (isolatedBaseDir) return (0, import_node_path5.join)(isolatedBaseDir, "config.json");
+  migrateLegacyAgentConfig({ profile });
+  return (0, import_node_path5.join)(DEFAULT_AGENT_DIR, resolveAgentConfigFileName(profile));
 }
 function configExistsAtPath(configPath) {
   return (0, import_node_fs5.existsSync)(configPath);
@@ -35760,13 +35522,22 @@ function explicitConfigPathFromArgs(args) {
   const prefix = "--config-path=";
   return args.find((arg) => arg.startsWith(prefix))?.slice(prefix.length).trim() || void 0;
 }
+function hasExplicitProfileArg(args) {
+  return args.some((arg) => arg === "--profile" || arg.startsWith("--profile="));
+}
 function bindAgentConfigPathFromArgs(args) {
   const argumentPath = explicitConfigPathFromArgs(args);
   if (argumentPath) {
     process.env.ALAN_AGENT_CONFIG_PATH = argumentPath;
     return argumentPath;
   }
-  const explicit = process.env.ALAN_AGENT_CONFIG_PATH?.trim();
+  if (hasExplicitProfileArg(args)) {
+    const profile2 = resolveEndpointProfileFromArgs(args);
+    const configPath2 = resolveAgentConfigPath({ profile: profile2 });
+    process.env.ALAN_AGENT_CONFIG_PATH = configPath2;
+    return configPath2;
+  }
+  const explicit = configuredConfigPathFromEnvironment();
   if (explicit) return explicit;
   const profile = resolveEndpointProfileFromArgs(args);
   const configPath = resolveAgentConfigPath({ profile });
@@ -37182,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")
@@ -39162,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))
@@ -45744,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 };
@@ -49088,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);
@@ -49162,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/);
@@ -49350,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),
@@ -49613,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,
@@ -49860,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);
@@ -53421,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",
@@ -53474,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)) {
@@ -53492,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)) {
@@ -53634,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,
@@ -53676,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,
@@ -53738,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) {
@@ -53772,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;
@@ -53839,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(
@@ -53867,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)) {
@@ -53883,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) => {
@@ -53902,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"
@@ -53910,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) {
@@ -53946,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) {
@@ -54409,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);
@@ -54474,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"]);
@@ -54553,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" },
@@ -54585,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], {
@@ -54655,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) {
@@ -55602,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 {
@@ -55683,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") : "";
@@ -55697,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;
@@ -55768,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();
@@ -55784,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) => ({
@@ -56096,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 = ":";
@@ -60269,9 +60235,9 @@ function buildMcpParamHeaders(declarations, args) {
   for (const decl of declarations) {
     const raw = valueAtPath(args, decl.path);
     if (raw === void 0 || raw === null) continue;
-    const stringValue = mcpParamPrimitiveToString(raw);
-    if (stringValue === void 0) continue;
-    out[`${MCP_PARAM_HEADER_PREFIX}${decl.headerName}`] = encodeMcpParamValue(stringValue);
+    const stringValue2 = mcpParamPrimitiveToString(raw);
+    if (stringValue2 === void 0) continue;
+    out[`${MCP_PARAM_HEADER_PREFIX}${decl.headerName}`] = encodeMcpParamValue(stringValue2);
   }
   return out;
 }
@@ -73145,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,
@@ -73946,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;
@@ -73993,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);
@@ -74012,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 {
@@ -74061,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(
@@ -74078,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");
@@ -74115,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)(
@@ -74228,7 +74194,7 @@ var NativeTranscriptStreamer = class {
         continue;
       }
       const parsed = parseJsonObject3(raw);
-      const events = parsed ? claudeRecordToAgentEvents(parsed) : [];
+      const events = parsed ? providerRecordToAgentEvents(hook.provider, parsed) : [];
       for (let index = 0; index < events.length; index += 1) {
         const deliveredEvent = events[index];
         const sourceCursor = `${start.generation}:${recordEndOffset}:${index}`;
@@ -74288,12 +74254,62 @@ function parseJsonObject3(value2) {
     return null;
   }
 }
-function claudeRecordToAgentEvents(record2) {
+function providerRecordToAgentEvents(provider, record2) {
+  if (provider === "codex") return codexRecordToAgentEvents(record2);
+  if (provider === "copilot") return copilotRecordToAgentEvents(record2);
+  return claudeCompatibleRecordToAgentEvents(record2);
+}
+function copilotRecordToAgentEvents(record2) {
+  if (typeof record2.type !== "string" || !isRecord2(record2.data)) return [];
+  const timestamp = timestampOf(record2) ? Date.parse(timestampOf(record2)) : Date.now();
+  const ts = Number.isFinite(timestamp) ? timestamp : Date.now();
+  const data = record2.data;
+  if (record2.type === "assistant.message") {
+    const events = [];
+    if (typeof data.reasoningText === "string" && data.reasoningText.length > 0) {
+      events.push({ type: "thinking", text: data.reasoningText, ts });
+    }
+    if (typeof data.content === "string" && data.content.length > 0) {
+      events.push({ type: "text", text: data.content, ts });
+    }
+    if (Array.isArray(data.toolRequests)) {
+      for (const request of data.toolRequests) {
+        if (!isRecord2(request)) continue;
+        const id = stringValue(request.id, request.toolCallId, request.tool_call_id);
+        const name = stringValue(request.name, request.toolName, request.tool_name);
+        if (id && name) {
+          events.push({
+            type: "tool_use",
+            id,
+            name,
+            input: request.arguments ?? request.input,
+            ts
+          });
+        }
+      }
+    }
+    return events;
+  }
+  if (record2.type === "tool.execution_complete" || record2.type === "tool.execution_end") {
+    const id = stringValue(data.toolCallId, data.tool_call_id, data.id);
+    if (!id) return [];
+    return [
+      {
+        type: "tool_result",
+        id,
+        content: extractText2(data.result ?? data.output ?? data.content),
+        ts
+      }
+    ];
+  }
+  return [];
+}
+function claudeCompatibleRecordToAgentEvents(record2) {
   const timestamp = timestampOf(record2) ? Date.parse(timestampOf(record2)) : Date.now();
   const ts = Number.isFinite(timestamp) ? timestamp : Date.now();
   const message = isRecord2(record2.message) ? record2.message : record2;
   const content = message.content;
-  const role = typeof message.role === "string" ? message.role : typeof record2.type === "string" ? record2.type : null;
+  const role = typeof message.role === "string" ? message.role : typeof record2.role === "string" ? record2.role : typeof record2.type === "string" ? record2.type : null;
   if (role === "user") {
     if (!Array.isArray(content)) return [];
     return content.flatMap((block) => {
@@ -74331,6 +74347,47 @@ function claudeRecordToAgentEvents(record2) {
     return [{ type: "text", text: content, ts }];
   return [];
 }
+function codexRecordToAgentEvents(record2) {
+  if (record2.type !== "response_item" || !isRecord2(record2.payload)) return [];
+  const payload = record2.payload;
+  const timestamp = timestampOf(record2) ? Date.parse(timestampOf(record2)) : Date.now();
+  const ts = Number.isFinite(timestamp) ? timestamp : Date.now();
+  if (payload.type === "message" && payload.role === "assistant") {
+    if (!Array.isArray(payload.content)) return [];
+    return payload.content.flatMap((block) => {
+      if (!isRecord2(block) || block.type !== "output_text" || typeof block.text !== "string") {
+        return [];
+      }
+      return block.text ? [{ type: "text", text: block.text, ts }] : [];
+    });
+  }
+  if (payload.type === "reasoning") {
+    const text = extractText2(payload.summary);
+    return text ? [{ type: "thinking", text, ts }] : [];
+  }
+  if (payload.type === "custom_tool_call") {
+    const id = stringValue(payload.call_id, payload.id);
+    const name = stringValue(payload.name);
+    if (!id || !name) return [];
+    return [{ type: "tool_use", id, name, input: parseEmbeddedJson(payload.input), ts }];
+  }
+  if (payload.type === "custom_tool_call_output") {
+    const id = stringValue(payload.call_id, payload.id);
+    return id ? [{ type: "tool_result", id, content: extractText2(payload.output), ts }] : [];
+  }
+  return [];
+}
+function stringValue(...values) {
+  return values.find((value2) => typeof value2 === "string" && value2.length > 0) ?? null;
+}
+function parseEmbeddedJson(value2) {
+  if (typeof value2 !== "string") return value2;
+  try {
+    return JSON.parse(value2);
+  } catch {
+    return value2;
+  }
+}
 function extractText2(value2) {
   if (typeof value2 === "string") return value2;
   if (Array.isArray(value2)) return value2.map(extractText2).filter(Boolean).join("\n");
@@ -74430,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) {
@@ -74574,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,
@@ -74615,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
@@ -75045,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,
@@ -75069,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);
   }
@@ -75090,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");
   }
@@ -75116,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;
@@ -75153,10 +75210,10 @@ function createIgnoreMatcher(path2) {
   const expression = globToRegExp(pattern);
   return (candidate) => expression.test(candidate) || expression.test(`${candidate}/`);
 }
-function isIgnored(normalizedPath, basename6, isDirectory2, configured) {
-  if (isDirectory2 && ALWAYS_IGNORED_DIRECTORIES.has(basename6))
+function isIgnored(normalizedPath, basename7, isDirectory2, configured) {
+  if (isDirectory2 && ALWAYS_IGNORED_DIRECTORIES.has(basename7))
     return true;
-  if (!isDirectory2 && ALWAYS_IGNORED_FILES.has(basename6))
+  if (!isDirectory2 && ALWAYS_IGNORED_FILES.has(basename7))
     return true;
   return configured.some((matches) => matches(normalizedPath));
 }
@@ -75183,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;
@@ -75223,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");
@@ -75251,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))
@@ -75360,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;
@@ -75597,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);
@@ -75669,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({
@@ -75735,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"
@@ -75760,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(homeDirectory) {
-  const configDirectory = (0, import_node_path18.join)(homeDirectory, ".alan");
-  const configPath = (0, import_node_path18.join)(configDirectory, "config.toml");
+async function loadSkillSourceConfig(homeDirectory2) {
+  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 {
@@ -75780,18 +75837,18 @@ async function loadSkillSourceConfig(homeDirectory) {
   }
   const content = await (0, import_promises2.readFile)(configPath, "utf8");
   try {
-    return { state: "ready", config: parseSkillSourceConfig(content, homeDirectory), created };
+    return { state: "ready", config: parseSkillSourceConfig(content, homeDirectory2), created };
   } catch (error61) {
     return {
       state: "invalid",
-      config: parseSkillSourceConfig(DEFAULT_SKILL_CONFIG, homeDirectory),
+      config: parseSkillSourceConfig(DEFAULT_SKILL_CONFIG, homeDirectory2),
       created: false,
       diagnostic: error61 instanceof Error ? error61.message : String(error61)
     };
   }
 }
-async function resolveSkillScanInput(homeDirectory, declared) {
-  const loaded = await loadSkillSourceConfig(homeDirectory);
+async function resolveSkillScanInput(homeDirectory2, declared) {
+  const loaded = await loadSkillSourceConfig(homeDirectory2);
   if (loaded.state === "invalid") {
     throw Object.assign(new Error(`Invalid Skill source configuration: ${loaded.diagnostic}`), {
       code: "SKILL_SOURCE_CONFIG_INVALID"
@@ -75799,7 +75856,7 @@ async function resolveSkillScanInput(homeDirectory, 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)(homeDirectory, ".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) {
@@ -75807,7 +75864,7 @@ async function resolveSkillScanInput(homeDirectory, 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,
@@ -75823,7 +75880,7 @@ async function resolveSkillScanInput(homeDirectory, declared) {
     ignoredPaths: [.../* @__PURE__ */ new Set([...config2.ignoredPaths, ...declared.ignoredPaths ?? []])]
   };
 }
-function parseSkillSourceConfig(content, homeDirectory) {
+function parseSkillSourceConfig(content, homeDirectory2) {
   const parsed = parse5(content);
   if (!isRecord4(parsed) || parsed.version !== 1 || !isRecord4(parsed.skills)) {
     throw new Error("~/.alan/config.toml must contain version = 1 and a [skills] table");
@@ -75846,7 +75903,7 @@ function parseSkillSourceConfig(content, homeDirectory) {
         `skills.sources entry ${index + 1} must contain string path and label values`
       );
     }
-    const sourcePath = resolveSkillSourcePath(value2.path, homeDirectory);
+    const sourcePath = resolveSkillSourcePath(value2.path, homeDirectory2);
     const label = value2.label.trim();
     if (!label) throw new Error(`skills.sources entry ${index + 1} has an empty label`);
     const declarationId = value2.id === void 0 ? stableSourceDeclarationId(sourcePath) : requiredSourceId(value2.id, `skills.sources[${index}].id`);
@@ -75854,7 +75911,7 @@ function parseSkillSourceConfig(content, homeDirectory) {
       value2.providers,
       `skills.sources[${index}].providers`
     );
-    const relativeDirectory = import_node_path18.default.relative(homeDirectory, 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);
@@ -75884,14 +75941,14 @@ function requiredSourceId(value2, field) {
   }
   return value2;
 }
-function resolveSkillSourcePath(sourcePath, homeDirectory, pathApi = import_node_path18.default) {
+function resolveSkillSourcePath(sourcePath, homeDirectory2, pathApi = import_node_path19.default) {
   const trimmed = sourcePath.trim();
-  if (trimmed === "~") return pathApi.resolve(homeDirectory);
+  if (trimmed === "~") return pathApi.resolve(homeDirectory2);
   if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
     const components = trimmed.slice(2).split(/[\\/]+/).filter(Boolean);
-    return pathApi.resolve(pathApi.join(homeDirectory, ...components));
+    return pathApi.resolve(pathApi.join(homeDirectory2, ...components));
   }
-  return pathApi.isAbsolute(trimmed) ? pathApi.resolve(trimmed) : pathApi.resolve(homeDirectory, trimmed);
+  return pathApi.isAbsolute(trimmed) ? pathApi.resolve(trimmed) : pathApi.resolve(homeDirectory2, trimmed);
 }
 function optionalBoolean(value2, fallback, field) {
   if (value2 === void 0) return fallback;
@@ -75919,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")}`
         });
       }
@@ -75978,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;
@@ -76147,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: {},
@@ -76171,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)) {
@@ -76270,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")}`
     );
@@ -76356,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);
@@ -76365,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",
@@ -76480,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;
@@ -76565,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(),
@@ -76731,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");
@@ -76745,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) {
@@ -76800,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;
@@ -76809,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 }
@@ -76830,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",
@@ -76856,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")}`
@@ -76877,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 }
@@ -76933,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);
@@ -76950,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)) {
@@ -76982,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);
@@ -76997,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 }
@@ -77022,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 }
@@ -77079,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;
@@ -77093,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);
@@ -77104,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;
   }
@@ -77116,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;
@@ -77156,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;
@@ -77164,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 });
 }
@@ -77324,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();
@@ -77404,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`);
@@ -77539,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) {
@@ -78247,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") {
@@ -78270,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",
@@ -78354,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)();
@@ -78366,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(),
@@ -78790,25 +78847,18 @@ 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),
   debug: () => {
   }
 };
-var HOME = (0, import_node_os12.homedir)();
-var PATHS = {
-  claude: (0, import_node_path23.join)(HOME, ".claude.json"),
-  codex: (0, import_node_path23.join)(HOME, ".codex", "config.toml"),
-  cursor: (0, import_node_path23.join)(HOME, ".cursor", "mcp.json"),
-  antigravity: (0, import_node_path23.join)(HOME, ".gemini", "config", "mcp_config.json"),
-  kimi: (0, import_node_path23.join)(HOME, ".kimi", "mcp.json"),
-  opencode: (0, import_node_path23.join)(HOME, ".config", "opencode", "opencode.json"),
-  factory: (0, import_node_path23.join)(HOME, ".factory", "mcp.json"),
-  amp: (0, import_node_path23.join)(HOME, ".config", "amp", "settings.json")
-};
+var homeDirectoryOverride;
+function homeDirectory() {
+  return homeDirectoryOverride ?? (0, import_node_os13.homedir)();
+}
 var MalformedToolConfigError = class extends Error {
 };
 function parseJsonSafe2(content) {
@@ -78826,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) {
@@ -78852,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" });
@@ -78869,9 +78919,12 @@ function saveMalformedBackup2(path2, content) {
 }
 var claudeAdapter = {
   cli: "Claude Code",
-  configPath: PATHS.claude,
-  guardDir: HOME,
-  // ~/.claude.json lives in home — always exists
+  get configPath() {
+    return (0, import_node_path24.join)(homeDirectory(), ".claude.json");
+  },
+  get guardDir() {
+    return homeDirectory();
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcpServers = config2.mcpServers ?? {};
@@ -78899,8 +78952,12 @@ var claudeAdapter = {
 };
 var codexAdapter = {
   cli: "Codex",
-  configPath: PATHS.codex,
-  guardDir: (0, import_node_path23.join)(HOME, ".codex"),
+  get configPath() {
+    return (0, import_node_path24.join)(homeDirectory(), ".codex", "config.toml");
+  },
+  get guardDir() {
+    return (0, import_node_path24.join)(homeDirectory(), ".codex");
+  },
   merge(existing, servers) {
     let config2 = {};
     if (existing) {
@@ -78941,8 +78998,12 @@ var codexAdapter = {
 };
 var cursorAdapter = {
   cli: "Cursor",
-  configPath: PATHS.cursor,
-  guardDir: (0, import_node_path23.join)(HOME, ".cursor"),
+  get configPath() {
+    return (0, import_node_path24.join)(homeDirectory(), ".cursor", "mcp.json");
+  },
+  get guardDir() {
+    return (0, import_node_path24.join)(homeDirectory(), ".cursor");
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcpServers = config2.mcpServers ?? {};
@@ -78971,8 +79032,12 @@ var cursorAdapter = {
 function createAntigravityAdapter() {
   return {
     cli: "Antigravity CLI",
-    configPath: PATHS.antigravity,
-    guardDir: (0, import_node_path23.join)(HOME, ".gemini", "config"),
+    get configPath() {
+      return (0, import_node_path24.join)(homeDirectory(), ".gemini", "config", "mcp_config.json");
+    },
+    get guardDir() {
+      return (0, import_node_path24.join)(homeDirectory(), ".gemini", "config");
+    },
     merge(existing, servers) {
       const config2 = parseJsonSafe2(existing);
       const mcpServers = config2.mcpServers ?? {};
@@ -79002,8 +79067,12 @@ function createAntigravityAdapter() {
 var antigravityAdapter = createAntigravityAdapter();
 var kimiAdapter = {
   cli: "Kimi CLI",
-  configPath: PATHS.kimi,
-  guardDir: (0, import_node_path23.join)(HOME, ".kimi"),
+  get configPath() {
+    return (0, import_node_path24.join)(homeDirectory(), ".kimi", "mcp.json");
+  },
+  get guardDir() {
+    return (0, import_node_path24.join)(homeDirectory(), ".kimi");
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcpServers = config2.mcpServers ?? {};
@@ -79031,8 +79100,12 @@ var kimiAdapter = {
 };
 var opencodeAdapter = {
   cli: "OpenCode",
-  configPath: PATHS.opencode,
-  guardDir: (0, import_node_path23.join)(HOME, ".config", "opencode"),
+  get configPath() {
+    return (0, import_node_path24.join)(homeDirectory(), ".config", "opencode", "opencode.json");
+  },
+  get guardDir() {
+    return (0, import_node_path24.join)(homeDirectory(), ".config", "opencode");
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcp = config2.mcp ?? {};
@@ -79060,8 +79133,12 @@ var opencodeAdapter = {
 };
 var factoryAdapter = {
   cli: "Factory Droid",
-  configPath: PATHS.factory,
-  guardDir: (0, import_node_path23.join)(HOME, ".factory"),
+  get configPath() {
+    return (0, import_node_path24.join)(homeDirectory(), ".factory", "mcp.json");
+  },
+  get guardDir() {
+    return (0, import_node_path24.join)(homeDirectory(), ".factory");
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcpServers = config2.mcpServers ?? {};
@@ -79096,8 +79173,12 @@ var factoryAdapter = {
 };
 var ampAdapter = {
   cli: "Amp",
-  configPath: PATHS.amp,
-  guardDir: (0, import_node_path23.join)(HOME, ".config", "amp"),
+  get configPath() {
+    return (0, import_node_path24.join)(homeDirectory(), ".config", "amp", "settings.json");
+  },
+  get guardDir() {
+    return (0, import_node_path24.join)(homeDirectory(), ".config", "amp");
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcpServers = config2["amp.mcpServers"] ?? {};
@@ -79203,6 +79284,77 @@ function normalizeAlanRuntimeEntry(actual, expected) {
 function matchesAlanManagedEntry(actual, expected) {
   return entriesMatch(actual, expected) || entriesMatch(normalizeAlanRuntimeEntry(actual, expected), expected);
 }
+var LOCAL_ALAN_MCP_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0"]);
+var LEGACY_LOCAL_ALAN_MCP_PORTS = /* @__PURE__ */ new Set(["8400"]);
+var ALAN_MCP_HOST_SUFFIXES = [".tryalan.ai"];
+function normalizeMcpPathname(pathname) {
+  const trimmed = pathname.replace(/\/+$/, "");
+  return trimmed.length > 0 ? trimmed : "/";
+}
+function urlsShareAlanMcpEndpoint(left, right) {
+  try {
+    const a = new URL(left);
+    const b = new URL(right);
+    return a.origin === b.origin && normalizeMcpPathname(a.pathname) === normalizeMcpPathname(b.pathname);
+  } catch {
+    return left === right;
+  }
+}
+function configuredAlanMcpUrlsFromEnv() {
+  const urls = [];
+  for (const raw of [
+    process.env.ALAN_MCP_DESKTOP_URL,
+    process.env.ALAN_MCP_PUBLIC_URL,
+    process.env.ALAN_LOCAL_API_URL
+  ]) {
+    const value2 = raw?.trim();
+    if (!value2) continue;
+    try {
+      const parsed = new URL(value2);
+      if (normalizeMcpPathname(parsed.pathname) === "/mcp") {
+        urls.push(parsed.toString());
+        continue;
+      }
+      parsed.pathname = "/mcp";
+      urls.push(parsed.toString());
+    } catch {
+      urls.push(value2.endsWith("/mcp") ? value2 : `${value2.replace(/\/$/, "")}/mcp`);
+    }
+  }
+  return urls;
+}
+function extractHttpUrlFromEntry(entry) {
+  if (!entry || typeof entry !== "object") return void 0;
+  const record2 = entry;
+  for (const key of ["url", "serverUrl"]) {
+    const value2 = record2[key];
+    if (typeof value2 === "string" && value2.length > 0) return value2;
+  }
+  for (const value2 of Object.values(record2)) {
+    if (!value2 || typeof value2 !== "object") continue;
+    const nested = extractHttpUrlFromEntry(value2);
+    if (nested) return nested;
+  }
+  return void 0;
+}
+function isAlanSelfRegistrationEntry(entry) {
+  const url3 = extractHttpUrlFromEntry(entry);
+  if (!url3) return false;
+  try {
+    const parsed = new URL(url3);
+    if (normalizeMcpPathname(parsed.pathname) !== "/mcp") return false;
+    const host = parsed.hostname.toLowerCase();
+    if (LOCAL_ALAN_MCP_HOSTS.has(host) && LEGACY_LOCAL_ALAN_MCP_PORTS.has(parsed.port)) {
+      return true;
+    }
+    if (ALAN_MCP_HOST_SUFFIXES.some((suffix) => host.endsWith(suffix))) return true;
+    return configuredAlanMcpUrlsFromEnv().some(
+      (configured) => urlsShareAlanMcpEndpoint(configured, url3)
+    );
+  } catch {
+    return false;
+  }
+}
 function hasAlanManagedSignature(entry) {
   if (!entry || typeof entry !== "object") return false;
   for (const [key, value2] of Object.entries(entry)) {
@@ -79223,6 +79375,9 @@ function expectedServerEntry(adapter, server) {
 function isManagedServerList(entries) {
   return entries.length === 0 || typeof entries[0] !== "string";
 }
+function isAlanOwnedMcpEntry(entry, desiredEntry, previousEntry) {
+  return hasAlanManagedSignature(entry) || isAlanSelfRegistrationEntry(entry) || matchesAlanManagedEntry(entry, desiredEntry) || previousEntry !== void 0 && matchesAlanManagedEntry(entry, previousEntry);
+}
 function syncMcpToAllClis(servers, oldManagedServers = []) {
   const written = [];
   const failures = [];
@@ -79237,6 +79392,7 @@ function syncMcpToAllClis(servers, oldManagedServers = []) {
     try {
       const existing = readFileOr(adapter.configPath);
       const previousServers = isManagedServerList(oldManagedServers) ? oldManagedServers : [];
+      const previousNames = isManagedServerList(oldManagedServers) ? oldManagedServers.map((server) => server.name) : oldManagedServers;
       const previousByName = new Map(previousServers.map((server) => [server.name, server]));
       if (existing) {
         for (const server of servers) {
@@ -79245,21 +79401,20 @@ function syncMcpToAllClis(servers, oldManagedServers = []) {
           const desiredEntry = expectedServerEntry(adapter, server);
           const previous = previousByName.get(server.name);
           const previousEntry = previous ? expectedServerEntry(adapter, previous) : void 0;
-          if (!hasAlanManagedSignature(currentEntry) && !matchesAlanManagedEntry(currentEntry, desiredEntry) && (!previousEntry || !matchesAlanManagedEntry(currentEntry, previousEntry))) {
+          if (!isAlanOwnedMcpEntry(currentEntry, desiredEntry, previousEntry)) {
             throw new Error(`an unowned entry already uses the name ${server.name}`);
           }
         }
       }
       const currentNames = new Set(servers.map((s) => s.name));
-      const toRemove = previousServers.filter((server) => !currentNames.has(server.name));
+      const toRemove = previousNames.filter((name) => !currentNames.has(name));
       let content;
       if (toRemove.length > 0) {
-        const ownedNames = existing ? toRemove.filter(
-          (server) => matchesAlanManagedEntry(
-            serverEntry(adapter, existing, server.name),
-            expectedServerEntry(adapter, server)
-          )
-        ).map((server) => server.name) : [];
+        const ownedNames = existing ? toRemove.filter((name) => {
+          const entry = serverEntry(adapter, existing, name);
+          const previous = previousByName.get(name);
+          return hasAlanManagedSignature(entry) || isAlanSelfRegistrationEntry(entry) || previous !== void 0 && matchesAlanManagedEntry(entry, expectedServerEntry(adapter, previous));
+        }) : [];
         const cleaned = adapter.remove(existing, ownedNames);
         content = adapter.merge(cleaned, servers);
       } else {
@@ -79344,7 +79499,9 @@ function inspectAlanMcpPresence(expectedServers = [], candidateNames = DEFAULT_A
       if (entry === void 0) continue;
       const expected = expectedByName.get(name);
       const matchesExpected = expected ? matchesAlanManagedEntry(entry, expectedServerEntry(adapter, expected)) : false;
-      if (!hasAlanManagedSignature(entry) && !matchesExpected) continue;
+      if (!hasAlanManagedSignature(entry) && !matchesExpected && !isAlanSelfRegistrationEntry(entry)) {
+        continue;
+      }
       foundOnCli = true;
       serverNamesFound.add(name);
     }
@@ -79392,7 +79549,8 @@ var McpSyncService = class {
   managedServerNames;
   legacyServerNames;
   getStatus() {
-    const presence = inspectAlanMcpPresence([], this.managedServerNames);
+    const candidateNames = [.../* @__PURE__ */ new Set([...this.managedServerNames, ...this.legacyServerNames])];
+    const presence = inspectAlanMcpPresence([], candidateNames);
     return {
       configured: presence.configured,
       lastSyncAt: null,
@@ -79444,8 +79602,12 @@ 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";
+var ALAN_OPENCODE_PLUGIN_MARKER = "// alan-native-session-plugin";
 var CLAUDE_HOOK_EVENTS = [
   "SessionStart",
   "UserPromptSubmit",
@@ -79455,15 +79617,59 @@ var CLAUDE_HOOK_EVENTS = [
   "SubagentStop",
   "SessionEnd"
 ];
-var ALAN_HOOK_MARKER = "# alan-native-session-hook";
+var CODEX_HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PostToolUse",
+  "Stop",
+  "SubagentStart",
+  "SubagentStop",
+  "SessionEnd"
+];
+var COPILOT_HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PostToolUse",
+  "Stop",
+  "SubagentStop",
+  "SessionEnd"
+];
+var CURSOR_HOOK_EVENTS = [
+  "sessionStart",
+  "beforeSubmitPrompt",
+  "afterAgentResponse",
+  "stop",
+  "sessionEnd"
+];
+var KIMI_HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PostToolUse",
+  "Stop",
+  "Interrupt",
+  "SubagentStart",
+  "SubagentStop",
+  "SessionEnd"
+];
+var GROK_HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PostToolUse",
+  "Stop",
+  "StopFailure",
+  "StopCancelled",
+  "SubagentStart",
+  "SubagentStop",
+  "SessionEnd"
+];
 function shellQuote(value2) {
   return `'${value2.replaceAll("'", `'\\''`)}'`;
 }
 function powershellQuote(value2) {
   return `'${value2.replaceAll("'", "''")}'`;
 }
-function nativeHookCommand(input2) {
-  const args = [
+function hookArgs(input2) {
+  return [
     input2.cliEntry,
     "hook",
     "--config-path",
@@ -79474,21 +79680,23 @@ function nativeHookCommand(input2) {
     input2.event,
     ALAN_HOOK_MARKER
   ];
-  const environment = Object.entries(input2.environment ?? {});
-  for (const [key] of environment) {
+}
+function checkedEnvironment(environment) {
+  const entries = Object.entries(environment ?? {});
+  for (const [key] of entries) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
       throw new Error(`Invalid native hook environment variable: ${key}`);
     }
   }
+  return entries;
+}
+function nativeHookCommand(input2) {
+  const args = hookArgs(input2);
+  const environment = checkedEnvironment(input2.environment);
   if (environment.length === 0) {
-    return {
-      type: "command",
-      command: input2.nodeExecutable,
-      args,
-      timeout: 5
-    };
+    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 {
@@ -79507,7 +79715,40 @@ function nativeHookCommand(input2) {
     timeout: 5
   };
 }
-function readSettings(path2) {
+function nativeShellCommand(runtime, provider, event, platform6 = runtime.platform) {
+  const args = hookArgs({
+    configPath: runtime.configPath,
+    cliEntry: runtime.cliEntry,
+    provider,
+    event
+  });
+  const environment = checkedEnvironment(runtime.environment);
+  if (platform6 === "win32") {
+    const prefix2 = environment.map(([key, value2]) => `$env:${key}=${powershellQuote(value2)}`).join("; ");
+    const command2 = `& ${[runtime.nodeExecutable, ...args].map(powershellQuote).join(" ")}`;
+    return prefix2 ? `${prefix2}; ${command2}` : command2;
+  }
+  const prefix = environment.map(([key, value2]) => `${key}=${shellQuote(value2)}`).join(" ");
+  const command = [runtime.nodeExecutable, ...args].map(shellQuote).join(" ");
+  return prefix ? `${prefix} ${command}` : command;
+}
+function resolveRuntime(input2 = {}) {
+  const cliEntry = input2.cliEntry ?? process.argv[1];
+  const configPath = input2.configPath ?? process.env.ALAN_AGENT_CONFIG_PATH;
+  if (!cliEntry) throw new Error("Cannot resolve the alan-agent CLI entrypoint");
+  if (!configPath?.trim()) {
+    throw new Error("Cannot install native hooks without an exact Alan agent config path");
+  }
+  return {
+    configPath,
+    homeDir: input2.homeDir ?? (0, import_node_os14.homedir)(),
+    nodeExecutable: input2.nodeExecutable ?? process.execPath,
+    cliEntry,
+    environment: input2.environment,
+    platform: input2.platform ?? (0, import_node_os14.platform)()
+  };
+}
+function readSettings(path2, providerLabel) {
   if (!(0, import_node_fs22.existsSync)(path2)) return {};
   try {
     const value2 = JSON.parse((0, import_node_fs22.readFileSync)(path2, "utf8"));
@@ -79519,78 +79760,363 @@ function readSettings(path2) {
     const backup = `${path2}.malformed-${Date.now()}.bak`;
     (0, import_node_fs22.copyFileSync)(path2, backup);
     throw new Error(
-      `Claude settings were malformed and moved to ${backup}: ${error61 instanceof Error ? error61.message : String(error61)}`
+      `${providerLabel} settings were malformed and copied to ${backup}: ${error61 instanceof Error ? error61.message : String(error61)}`
     );
   }
 }
-function withoutAlanHookGroups(value2) {
+function withoutAlanEntries(value2) {
   if (!Array.isArray(value2)) return [];
-  return value2.filter((group) => !JSON.stringify(group).includes(ALAN_HOOK_MARKER));
+  return value2.filter((entry) => !JSON.stringify(entry).includes(ALAN_HOOK_MARKER));
 }
 function writeSettings(path2, settings) {
-  (0, import_node_fs22.mkdirSync)((0, import_node_path24.dirname)(path2), { recursive: true, mode: 448 });
+  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_path25.dirname)(path2), { recursive: true, mode: 448 });
   const temporary = `${path2}.${process.pid}.tmp`;
-  (0, import_node_fs22.writeFileSync)(temporary, `${JSON.stringify(settings, null, 2)}
-`, { mode: 384 });
+  (0, import_node_fs22.writeFileSync)(temporary, serialized, { mode: 384 });
   (0, import_node_fs22.renameSync)(temporary, path2);
+  return true;
 }
-function reconcileClaudeNativeHooks(input2) {
-  const homeDir = input2?.homeDir ?? (0, import_node_os13.homedir)();
-  const settingsPath = (0, import_node_path24.join)(homeDir, ".claude", "settings.json");
-  const nodeExecutable = input2?.nodeExecutable ?? process.execPath;
-  const cliEntry = input2?.cliEntry ?? process.argv[1];
-  const configPath = input2?.configPath ?? process.env.ALAN_AGENT_CONFIG_PATH;
-  if (!cliEntry) throw new Error("Cannot resolve the alan-agent CLI entrypoint");
-  if (!configPath?.trim()) {
-    throw new Error("Cannot install Claude hooks without an exact Alan agent config path");
+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_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);
+  return true;
+}
+function withoutMarkedSection(content, start, end) {
+  const startIndex = content.indexOf(start);
+  const endIndex = content.indexOf(end);
+  if (startIndex < 0 && endIndex < 0) return content;
+  if (startIndex < 0 || endIndex < startIndex) {
+    throw new Error(`Malformed Alan-owned configuration section: ${start}`);
   }
-  const settings = readSettings(settingsPath);
+  const afterEnd = endIndex + end.length;
+  return `${content.slice(0, startIndex).trimEnd()}
+${content.slice(afterEnd).trimStart()}`.trim();
+}
+function reconcileNestedCommandHooks(input2) {
+  const settings = readSettings(input2.path, input2.providerLabel);
   const currentHooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks) ? settings.hooks : {};
   const hooks = { ...currentHooks };
-  for (const event of CLAUDE_HOOK_EVENTS) {
+  for (const event of input2.events) {
+    hooks[event] = [...withoutAlanEntries(currentHooks[event]), { hooks: [input2.command(event)] }];
+  }
+  return writeSettings(input2.path, { ...settings, hooks });
+}
+function removeNestedCommandHooks(path2, providerLabel) {
+  if (!(0, import_node_fs22.existsSync)(path2)) return false;
+  const settings = readSettings(path2, providerLabel);
+  if (!settings.hooks || typeof settings.hooks !== "object" || Array.isArray(settings.hooks)) {
+    return false;
+  }
+  const hooks = {};
+  let removed = false;
+  for (const [event, groups] of Object.entries(settings.hooks)) {
+    const retained = withoutAlanEntries(groups);
+    if (Array.isArray(groups) && retained.length !== groups.length) removed = true;
+    if (retained.length > 0) hooks[event] = retained;
+  }
+  return removed ? writeSettings(path2, { ...settings, hooks }) : false;
+}
+function reconcileClaudeNativeHooks(input2 = {}) {
+  const runtime = resolveRuntime(input2);
+  return reconcileNestedCommandHooks({
+    path: (0, import_node_path25.join)(runtime.homeDir, ".claude", "settings.json"),
+    providerLabel: "Claude",
+    events: CLAUDE_HOOK_EVENTS,
+    command: (event) => ({
+      ...nativeHookCommand({
+        ...runtime,
+        provider: "claude_cli",
+        event
+      })
+    })
+  });
+}
+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_path25.join)(runtime.homeDir, ".codex", "hooks.json"),
+    providerLabel: "Codex",
+    events: CODEX_HOOK_EVENTS,
+    command: (event) => ({
+      type: "command",
+      command: nativeShellCommand(runtime, "codex_app_server", event, "darwin"),
+      commandWindows: nativeShellCommand(runtime, "codex_app_server", event, "win32"),
+      timeout: event === "SessionEnd" ? 3 : 5
+    })
+  });
+}
+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_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}`);
+  }
+  const hooks = Object.fromEntries(
+    COPILOT_HOOK_EVENTS.map((event) => [
+      event,
+      [
+        {
+          type: "command",
+          bash: nativeShellCommand(runtime, "copilot_cli", event, "darwin"),
+          powershell: nativeShellCommand(runtime, "copilot_cli", event, "win32"),
+          timeoutSec: event === "SessionEnd" ? 3 : 5
+        }
+      ]
+    ])
+  );
+  return writeSettings(path2, { version: 1, hooks });
+}
+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);
+  return true;
+}
+function reconcileCursorNativeHooks(input2 = {}) {
+  const runtime = resolveRuntime(input2);
+  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 };
+  for (const event of CURSOR_HOOK_EVENTS) {
     hooks[event] = [
-      ...withoutAlanHookGroups(currentHooks[event]),
+      ...withoutAlanEntries(currentHooks[event]),
       {
-        hooks: [
-          nativeHookCommand({
-            configPath,
-            nodeExecutable,
-            cliEntry,
-            environment: input2?.environment,
-            platform: input2?.platform,
-            provider: "claude_cli",
-            event
-          })
-        ]
+        type: "command",
+        command: nativeShellCommand(runtime, "cursor_agent_cli", event),
+        timeout: 5
       }
     ];
   }
-  const next = { ...settings, hooks };
-  const previous = (0, import_node_fs22.existsSync)(settingsPath) ? (0, import_node_fs22.readFileSync)(settingsPath, "utf8") : null;
-  const serialized = `${JSON.stringify(next, null, 2)}
-`;
-  if (previous === serialized) return false;
-  writeSettings(settingsPath, next);
-  return true;
+  return writeSettings(path2, { ...settings, version: settings.version ?? 1, hooks });
 }
-function removeClaudeNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
-  const settingsPath = (0, import_node_path24.join)(homeDir, ".claude", "settings.json");
-  if (!(0, import_node_fs22.existsSync)(settingsPath)) return false;
-  const settings = readSettings(settingsPath);
+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)) {
     return false;
   }
   const hooks = {};
   let removed = false;
-  for (const [event, groups] of Object.entries(settings.hooks)) {
-    const retained = withoutAlanHookGroups(groups);
-    if (Array.isArray(groups) && retained.length !== groups.length) removed = true;
+  for (const [event, entries] of Object.entries(settings.hooks)) {
+    const retained = withoutAlanEntries(entries);
+    if (Array.isArray(entries) && retained.length !== entries.length) removed = true;
     if (retained.length > 0) hooks[event] = retained;
   }
-  if (!removed) return false;
-  writeSettings(settingsPath, { ...settings, hooks });
+  return removed ? writeSettings(path2, { ...settings, hooks }) : false;
+}
+function kimiHookSection(runtime) {
+  const hooks = KIMI_HOOK_EVENTS.map(
+    (event) => [
+      "[[hooks]]",
+      `event = ${JSON.stringify(event)}`,
+      `command = ${JSON.stringify(nativeShellCommand(runtime, "kimi_cli", event))}`,
+      `timeout = ${event === "SessionEnd" ? 3 : 5}`
+    ].join("\n")
+  ).join("\n\n");
+  return `${ALAN_KIMI_HOOKS_START}
+${hooks}
+${ALAN_KIMI_HOOKS_END}`;
+}
+function reconcileKimiNativeHooks(input2 = {}) {
+  const runtime = resolveRuntime(input2);
+  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_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);
+  if (content === current) return false;
+  return writeTextFile(path2, content ? `${content.trimEnd()}
+` : "");
+}
+function reconcileGrokNativeHooks(input2 = {}) {
+  const runtime = resolveRuntime(input2);
+  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}`);
+  }
+  return reconcileNestedCommandHooks({
+    path: path2,
+    providerLabel: "Grok",
+    events: GROK_HOOK_EVENTS,
+    command: (event) => ({
+      type: "command",
+      command: nativeShellCommand(runtime, "grok_cli", event),
+      timeout: event === "SessionEnd" ? 3 : 5
+    })
+  });
+}
+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);
+  return true;
+}
+function opencodePluginSource(runtime) {
+  const command = [
+    runtime.nodeExecutable,
+    runtime.cliEntry,
+    "hook",
+    "--config-path",
+    runtime.configPath,
+    "--provider",
+    "opencode_cli"
+  ];
+  const environment = runtime.environment ?? {};
+  return `${ALAN_OPENCODE_PLUGIN_MARKER}
+const command = ${JSON.stringify(command)}
+const environment = ${JSON.stringify(environment)}
+
+export const AlanNativeSessionPlugin = async ({ directory }) => {
+  const textByPart = new Map()
+  const userPartIdsBySession = new Map()
+  const send = async (event, payload) => {
+    const proc = Bun.spawn({
+      cmd: [...command, "--event", event, ${JSON.stringify(ALAN_HOOK_MARKER)}],
+      env: { ...process.env, ...environment },
+      stdin: "pipe",
+      stdout: "ignore",
+      stderr: "ignore",
+    })
+    proc.stdin.write(JSON.stringify({ ...payload, cwd: payload.cwd ?? directory }))
+    proc.stdin.end()
+    await proc.exited
+  }
+
+  return {
+    "chat.message": async (input, output) => {
+      userPartIdsBySession.set(
+        input.sessionID,
+        new Set(output.parts.map((part) => part.id).filter(Boolean)),
+      )
+      const prompt = output.parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\\n")
+      await send("user_prompt", { session_id: input.sessionID, prompt })
+    },
+    event: async ({ event }) => {
+      if (event.type === "session.created") {
+        await send("session_start", { session_id: event.properties.info.id })
+        return
+      }
+      if (event.type === "session.idle") {
+        await send("stop", { session_id: event.properties.sessionID })
+        return
+      }
+      if (event.type === "session.deleted") {
+        userPartIdsBySession.delete(event.properties.info.id)
+        await send("session_end", { session_id: event.properties.info.id })
+        return
+      }
+      if (event.type === "session.error" && event.properties.sessionID) {
+        await send("stop", {
+          session_id: event.properties.sessionID,
+          error: event.properties.error,
+        })
+        return
+      }
+      if (event.type !== "message.part.updated") return
+      const part = event.properties.part
+      if (part.type !== "text" && part.type !== "reasoning") return
+      if (userPartIdsBySession.get(part.sessionID)?.has(part.id)) return
+      const previous = textByPart.get(part.id) ?? ""
+      const complete = typeof part.text === "string" ? part.text : ""
+      const text = event.properties.delta ?? (complete.startsWith(previous) ? complete.slice(previous.length) : complete)
+      textByPart.set(part.id, complete)
+      if (!text) return
+      await send("transcript_update", {
+        session_id: part.sessionID,
+        source_cursor: part.id + ":" + complete.length,
+        ...(part.type === "reasoning" ? { thinking: text } : { transcript_delta: text }),
+      })
+    },
+  }
+}
+`;
+}
+function reconcileOpencodeNativePlugin(input2 = {}) {
+  const runtime = resolveRuntime(input2);
+  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_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_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);
+  return true;
+}
+function configFileContainsMarker(path2, marker) {
+  if (!(0, import_node_fs22.existsSync)(path2)) return false;
+  try {
+    return (0, import_node_fs22.readFileSync)(path2, "utf8").includes(marker);
+  } catch {
+    return false;
+  }
+}
+function inspectNativeHooksConfigured(providerKind, homeDir = (0, import_node_os14.homedir)()) {
+  switch (providerKind) {
+    case "claude_cli":
+      return configFileContainsMarker((0, import_node_path25.join)(homeDir, ".claude", "settings.json"), ALAN_HOOK_MARKER);
+    case "codex_app_server":
+      return configFileContainsMarker((0, import_node_path25.join)(homeDir, ".codex", "hooks.json"), ALAN_HOOK_MARKER);
+    case "copilot_cli":
+      return configFileContainsMarker(
+        (0, import_node_path25.join)(homeDir, ".copilot", "hooks", "alan-native-session.json"),
+        ALAN_HOOK_MARKER
+      );
+    case "cursor_agent_cli":
+      return configFileContainsMarker((0, import_node_path25.join)(homeDir, ".cursor", "hooks.json"), ALAN_HOOK_MARKER);
+    case "kimi_cli":
+      return configFileContainsMarker(
+        (0, import_node_path25.join)(homeDir, ".kimi-code", "config.toml"),
+        ALAN_KIMI_HOOKS_START
+      );
+    case "grok_cli":
+      return configFileContainsMarker(
+        (0, import_node_path25.join)(homeDir, ".grok", "hooks", "alan-native-session.json"),
+        ALAN_HOOK_MARKER
+      );
+    case "opencode_cli":
+      return configFileContainsMarker(
+        (0, import_node_path25.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js"),
+        ALAN_OPENCODE_PLUGIN_MARKER
+      );
+    default:
+      return false;
+  }
+}
 
 // src/integration-cli.ts
 function alanMcpServers(apiUrl) {
@@ -79601,12 +80127,41 @@ function alanMcpServers(apiUrl) {
     }
   };
 }
+function reconcileInstalledNativeHooks(options) {
+  const environment = getDaemonCliEnvironment();
+  const nativeRuntime = {
+    configPath: options.configPath ?? getConfigPath(),
+    nodeExecutable: options.nativeHookRuntime?.executable,
+    cliEntry: options.nativeHookRuntime?.cliEntry,
+    environment: options.nativeHookRuntime?.environment
+  };
+  return [
+    resolveCliExecutable("claude", environment) ? reconcileClaudeNativeHooks(nativeRuntime) : false,
+    resolveCliExecutable("codex", environment) ? reconcileCodexNativeHooks(nativeRuntime) : false,
+    resolveCliExecutable("copilot", environment) ? reconcileCopilotNativeHooks(nativeRuntime) : false,
+    resolveCliExecutable("cursor-agent", environment) ? reconcileCursorNativeHooks(nativeRuntime) : false,
+    resolveCliExecutable("kimi-cli", environment) ? reconcileKimiNativeHooks(nativeRuntime) : false,
+    resolveCliExecutable("grok", environment) ? reconcileGrokNativeHooks(nativeRuntime) : false,
+    resolveCliExecutable("opencode", environment) ? reconcileOpencodeNativePlugin(nativeRuntime) : false
+  ].some(Boolean);
+}
+function removeNativeHooksOnly() {
+  removeClaudeNativeHooks();
+  removeCodexNativeHooks();
+  removeCopilotNativeHooks();
+  removeCursorNativeHooks();
+  removeKimiNativeHooks();
+  removeGrokNativeHooks();
+  removeOpencodeNativePlugin();
+}
 function runMcpIntegrationCommand(args, options = {}) {
   bindConfigPath(args);
   const action = args[0] ?? "status";
   const config2 = readConfig();
   const endpoints = resolveEndpoints(args.slice(1), config2);
   const service = new McpSyncService({ enabled: true });
+  const reconcileMcp = options.reconcileMcp ?? true;
+  const reconcileHooks = options.reconcileHooks ?? true;
   if (action === "status") {
     process.stdout.write(`${JSON.stringify(service.getStatus(), null, 2)}
 `);
@@ -79618,23 +80173,26 @@ function runMcpIntegrationCommand(args, options = {}) {
         "Alan is not configured. Run `alan-agent login` or `alan-agent setup` first."
       );
     }
-    const result = service.syncServers(alanMcpServers(endpoints.apiUrl), endpoints.apiUrl);
-    if (result.errors.length > 0) throw new Error(result.errors.join("; "));
-    const hooksUpdated = resolveCliExecutable("claude", getDaemonCliEnvironment()) ? reconcileClaudeNativeHooks({
-      configPath: getConfigPath(),
-      nodeExecutable: options.nativeHookRuntime?.executable,
-      cliEntry: options.nativeHookRuntime?.cliEntry,
-      environment: options.nativeHookRuntime?.environment
-    }) : false;
+    let mcpServersUpdated = false;
+    if (reconcileMcp) {
+      const result = service.syncServers(alanMcpServers(endpoints.apiUrl), endpoints.apiUrl);
+      if (result.errors.length > 0) throw new Error(result.errors.join("; "));
+      mcpServersUpdated = result.mcpServersUpdated;
+    }
+    const hooksUpdated = reconcileHooks ? reconcileInstalledNativeHooks(options) : false;
     process.stdout.write(
-      `${result.mcpServersUpdated || hooksUpdated ? "Alan CLI integrations updated" : "Alan CLI integrations already current"}.
+      `${mcpServersUpdated || hooksUpdated ? "Alan CLI integrations updated" : "Alan CLI integrations already current"}.
 `
     );
     return;
   }
   if (action === "uninstall") {
-    service.cleanup(toManagedMcpServers(alanMcpServers(endpoints.apiUrl)));
-    removeClaudeNativeHooks();
+    if (reconcileMcp) {
+      service.cleanup(toManagedMcpServers(alanMcpServers(endpoints.apiUrl)));
+    }
+    if (reconcileHooks) {
+      removeNativeHooksOnly();
+    }
     process.stdout.write("Removed Alan-owned MCP configuration.\n");
     return;
   }
@@ -79716,7 +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_path25 = require("path");
+var import_node_os15 = require("os");
+var import_node_path26 = require("path");
 
 // src/native-session.ts
 var NATIVE_SESSION_PROVIDER_CAPABILITIES = [
@@ -79748,28 +80307,64 @@ var NATIVE_SESSION_PROVIDER_CAPABILITIES = [
     command: "codex",
     capabilities: {
       mcp: true,
-      lifecycleHooks: false,
-      transcriptDelta: false,
-      subagents: false,
-      sessionEnd: false,
-      state: "degraded",
-      reason: "Codex exposes a turn-complete notification, not full lifecycle hooks."
+      lifecycleHooks: true,
+      transcriptDelta: true,
+      subagents: true,
+      sessionEnd: true,
+      state: "supported"
     },
-    supportedHookEvents: ["agent-turn-complete"]
+    supportedHookEvents: [
+      "SessionStart",
+      "UserPromptSubmit",
+      "PostToolUse",
+      "Stop",
+      "SubagentStart",
+      "SubagentStop",
+      "SessionEnd"
+    ]
   },
   {
     providerKind: "copilot_cli",
     provider: "copilot",
     command: "copilot",
-    capabilities: unsupportedMcpOnlyCapability(),
-    supportedHookEvents: []
+    capabilities: {
+      mcp: true,
+      lifecycleHooks: true,
+      transcriptDelta: true,
+      subagents: false,
+      sessionEnd: true,
+      state: "supported",
+      reason: "Copilot exposes stable subagent identity only on SubagentStop, so paired subagent lifecycle is not projected."
+    },
+    supportedHookEvents: [
+      "SessionStart",
+      "UserPromptSubmit",
+      "PostToolUse",
+      "Stop",
+      "SubagentStop",
+      "SessionEnd"
+    ]
   },
   {
     providerKind: "cursor_agent_cli",
     provider: "cursor",
     command: "cursor-agent",
-    capabilities: unsupportedMcpOnlyCapability(),
-    supportedHookEvents: []
+    capabilities: {
+      mcp: true,
+      lifecycleHooks: true,
+      transcriptDelta: true,
+      subagents: false,
+      sessionEnd: true,
+      state: "supported",
+      reason: "Cursor's subagent stop hook does not expose the stable subagent id from subagent start."
+    },
+    supportedHookEvents: [
+      "sessionStart",
+      "beforeSubmitPrompt",
+      "afterAgentResponse",
+      "stop",
+      "sessionEnd"
+    ]
   },
   {
     providerKind: "antigravity_cli",
@@ -79782,22 +80377,70 @@ var NATIVE_SESSION_PROVIDER_CAPABILITIES = [
     providerKind: "kimi_cli",
     provider: "kimi",
     command: "kimi-cli",
-    capabilities: unsupportedMcpOnlyCapability(),
-    supportedHookEvents: []
+    capabilities: {
+      mcp: true,
+      lifecycleHooks: true,
+      transcriptDelta: true,
+      subagents: false,
+      sessionEnd: true,
+      state: "supported",
+      reason: "Kimi hooks identify subagents by name but do not expose a stable child session id."
+    },
+    supportedHookEvents: [
+      "SessionStart",
+      "UserPromptSubmit",
+      "PostToolUse",
+      "Stop",
+      "Interrupt",
+      "SubagentStart",
+      "SubagentStop",
+      "SessionEnd"
+    ]
   },
   {
     providerKind: "grok_cli",
     provider: "grok",
     command: "grok",
-    capabilities: unsupportedMcpOnlyCapability(),
-    supportedHookEvents: []
+    capabilities: {
+      mcp: true,
+      lifecycleHooks: true,
+      transcriptDelta: false,
+      subagents: false,
+      sessionEnd: true,
+      state: "supported",
+      reason: "Grok supplies the final assistant message on terminal hooks, but not incremental transcript deltas or stable child session ids."
+    },
+    supportedHookEvents: [
+      "SessionStart",
+      "UserPromptSubmit",
+      "PostToolUse",
+      "Stop",
+      "StopFailure",
+      "StopCancelled",
+      "SubagentStart",
+      "SubagentStop",
+      "SessionEnd"
+    ]
   },
   {
     providerKind: "opencode_cli",
     provider: "opencode",
     command: "opencode",
-    capabilities: unsupportedMcpOnlyCapability(),
-    supportedHookEvents: []
+    capabilities: {
+      mcp: true,
+      lifecycleHooks: true,
+      transcriptDelta: true,
+      subagents: false,
+      sessionEnd: true,
+      state: "supported",
+      reason: "OpenCode exposes root session and message events; subagent lifecycle is not distinct."
+    },
+    supportedHookEvents: [
+      "session.created",
+      "message.part.updated",
+      "session.idle",
+      "session.deleted"
+    ]
   },
   {
     providerKind: "droid_cli",
@@ -79847,6 +80490,17 @@ function stringField4(payload, ...names) {
   }
   return void 0;
 }
+function firstStringArrayField(payload, ...names) {
+  for (const name of names) {
+    const value2 = payload[name];
+    if (!Array.isArray(value2)) continue;
+    const first = value2.find(
+      (entry) => typeof entry === "string" && entry.trim().length > 0
+    );
+    if (first) return first.trim();
+  }
+  return void 0;
+}
 function nonNegativeIntegerField(payload, ...names) {
   for (const name of names) {
     const value2 = payload[name];
@@ -79854,19 +80508,77 @@ function nonNegativeIntegerField(payload, ...names) {
   }
   return void 0;
 }
+function resolveCodexSessionIdFromTranscriptPath(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_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_path26.join)(
+      sessionsDir,
+      workspace.name,
+      externalSessionId,
+      "agents",
+      "main",
+      "wire.jsonl"
+    );
+    if ((0, import_node_fs23.existsSync)(transcriptPath)) return transcriptPath;
+  }
+  return void 0;
+}
+function enrichProviderPayload(provider, payload) {
+  if (provider === "codex_app_server") {
+    const externalSessionId2 = stringField4(
+      payload,
+      "session_id",
+      "sessionId",
+      "thread_id",
+      "threadId"
+    );
+    if (externalSessionId2) return payload;
+    const transcriptPath2 = stringField4(payload, "transcript_path", "transcriptPath");
+    if (!transcriptPath2) return payload;
+    const derivedSessionId = resolveCodexSessionIdFromTranscriptPath(transcriptPath2);
+    return derivedSessionId ? { ...payload, session_id: derivedSessionId } : payload;
+  }
+  if (provider !== "kimi_cli") return payload;
+  const externalSessionId = stringField4(payload, "session_id", "sessionId");
+  if (!externalSessionId || stringField4(payload, "transcript_path", "transcriptPath")) {
+    return payload;
+  }
+  const transcriptPath = resolveKimiTranscriptPath(externalSessionId);
+  return transcriptPath ? { ...payload, transcript_path: transcriptPath } : payload;
+}
 function parseNativeHookEnvelope(input2) {
   if (!isNativeSessionProviderKind(input2.provider)) {
     throw new Error(`unsupported native session provider: ${input2.provider}`);
   }
-  const rawHookEvent = input2.hookEvent ?? stringField4(input2.payload, "hook_event_name", "hookEvent", "type") ?? "notification";
-  const cwd = stringField4(input2.payload, "cwd", "working_directory", "workingDirectory");
-  const transcriptPath = stringField4(input2.payload, "transcript_path", "transcriptPath");
+  const payload = enrichProviderPayload(input2.provider, input2.payload);
+  const rawHookEvent = input2.hookEvent ?? stringField4(payload, "hook_event_name", "hookEvent", "hookEventName", "type") ?? "notification";
+  const eventType = normalizeHookEvent(rawHookEvent);
+  const cwd = stringField4(payload, "cwd", "working_directory", "workingDirectory") ?? firstStringArrayField(payload, "workspace_roots", "workspaceRoots");
+  const transcriptPath = eventType === "subagent_start" || eventType === "subagent_end" ? stringField4(
+    payload,
+    "agent_transcript_path",
+    "agentTranscriptPath",
+    "transcript_path",
+    "transcriptPath"
+  ) : stringField4(payload, "transcript_path", "transcriptPath");
   const capability = NATIVE_SESSION_PROVIDER_CAPABILITIES.find(
     (candidate) => candidate.providerKind === input2.provider
   );
   if (!capability) throw new Error(`unsupported native session provider: ${input2.provider}`);
-  const externalSessionId = stringField4(
-    input2.payload,
+  const parentSessionId = stringField4(
+    payload,
+    "parent_session_id",
+    "parentSessionId",
     "session_id",
     "sessionId",
     "conversation_id",
@@ -79874,20 +80586,30 @@ function parseNativeHookEnvelope(input2) {
     "thread_id",
     "threadId"
   );
+  const externalSessionId = eventType === "subagent_start" || eventType === "subagent_end" ? stringField4(
+    payload,
+    "agent_id",
+    "agentId",
+    "subagent_id",
+    "subagentId",
+    "task_id",
+    "taskId"
+  ) ?? parentSessionId : parentSessionId;
   if (!externalSessionId) throw new Error("hook payload is missing a provider session id");
-  const cursor = stringField4(input2.payload, "source_cursor", "sourceCursor") ?? nonNegativeIntegerField(input2.payload, "byte_offset", "byteOffset")?.toString() ?? nonNegativeIntegerField(input2.payload, "sequence", "seq")?.toString();
+  const cursor = stringField4(payload, "source_cursor", "sourceCursor") ?? nonNegativeIntegerField(payload, "byte_offset", "byteOffset")?.toString() ?? nonNegativeIntegerField(payload, "sequence", "seq")?.toString();
+  const providerPayload = capability.providerKind === "cursor_agent_cli" && eventType === "transcript_update" && !transcriptPath && typeof payload.text === "string" ? { ...payload, assistant_response: payload.text } : payload;
   return {
     schemaVersion: 1,
     eventId: (0, import_node_crypto19.randomUUID)(),
     provider: capability.provider,
-    eventType: normalizeHookEvent(rawHookEvent),
+    eventType,
     observedAt: (input2.now ?? /* @__PURE__ */ new Date()).toISOString(),
     externalSessionId,
-    parentExternalSessionId: stringField4(input2.payload, "parent_session_id", "parentSessionId"),
-    ...cwd ? { cwd: (0, import_node_path25.resolve)(cwd) } : {},
-    ...transcriptPath ? { transcriptPath: (0, import_node_path25.resolve)(transcriptPath) } : {},
+    ...(eventType === "subagent_start" || eventType === "subagent_end") && parentSessionId ? { parentExternalSessionId: parentSessionId } : {},
+    ...cwd ? { cwd: (0, import_node_path26.resolve)(cwd) } : {},
+    ...transcriptPath ? { transcriptPath: (0, import_node_path26.resolve)(transcriptPath) } : {},
     ...cursor ? { sourceCursor: cursor } : {},
-    providerPayload: input2.payload
+    providerPayload
   };
 }
 function normalizeHookEvent(raw) {
@@ -79896,6 +80618,8 @@ function normalizeHookEvent(raw) {
     case "session_start":
       return "session_start";
     case "userpromptsubmit":
+    case "userpromptsubmitted":
+    case "beforesubmitprompt":
     case "user_prompt":
       return "user_prompt";
     case "subagentstart":
@@ -79908,8 +80632,19 @@ function normalizeHookEvent(raw) {
     case "session_end":
       return "session_end";
     case "stop":
+    case "agentstop":
+    case "agent_stop":
     case "agent_turn_complete":
+    case "stopfailure":
+    case "stop_failure":
+    case "stopcancelled":
+    case "stop_cancelled":
+    case "interrupt":
       return "stop";
+    case "afteragentresponse":
+    case "message.part.updated":
+    case "transcript_update":
+      return "transcript_update";
     default:
       return "transcript_update";
   }
@@ -79954,21 +80689,34 @@ function runNativeHookCommand(args) {
   try {
     const payload = readBoundedHookPayload();
     const enqueued = enqueueNativeHookFromConfig({ args, payload });
-    const hookEvent = argumentValue(args, "--event")?.toLowerCase();
-    if (enqueued && (hookEvent === "userpromptsubmit" || hookEvent === "user_prompt")) {
+    const hookEvent = argumentValue(args, "--event");
+    const normalizedEvent = normalizeHookEvent(hookEvent ?? "notification");
+    if (enqueued && (normalizedEvent === "user_prompt" || normalizedEvent === "session_start")) {
       const providerKind = argumentValue(args, "--provider");
-      const externalSessionId = stringField4(payload, "session_id", "sessionId");
+      const externalSessionId = stringField4(
+        payload,
+        "session_id",
+        "sessionId",
+        "conversation_id",
+        "conversationId",
+        "thread_id",
+        "threadId"
+      );
       const capability = providerKind ? NATIVE_SESSION_PROVIDER_CAPABILITIES.find(
         (candidate) => candidate.providerKind === providerKind
       ) : void 0;
-      if (capability && externalSessionId) {
+      const shouldInjectLinkingContext = capability && externalSessionId && (capability.providerKind === "claude_cli" || capability.providerKind === "codex_app_server" || capability.providerKind === "kimi_cli" ? normalizedEvent === "user_prompt" : capability.providerKind === "cursor_agent_cli" && normalizedEvent === "session_start");
+      if (shouldInjectLinkingContext && capability && externalSessionId) {
+        const additionalContext = `First call get_native_session_link_status with provider=${capability.provider} and externalSessionId=${externalSessionId}. If status is linked, continue without asking or linking again. If status is syncing, wait briefly and retry the status check. Only when status is pending, ask the user one question: work on an Alan task or continue as a direct session. Resolve a named task with find_records, then call link_native_session. Do not guess a task and do not change task status.`;
         process.stdout.write(
-          `${JSON.stringify({
-            hookSpecificOutput: {
-              hookEventName: "UserPromptSubmit",
-              additionalContext: `First call get_native_session_link_status with provider=${capability.provider} and externalSessionId=${externalSessionId}. If status is linked, continue without asking or linking again. If status is syncing, wait briefly and retry the status check. Only when status is pending, ask the user one question: work on an Alan task or continue as a direct session. Resolve a named task with find_records, then call link_native_session. Do not guess a task and do not change task status.`
+          `${JSON.stringify(
+            capability.providerKind === "cursor_agent_cli" ? { additional_context: additionalContext } : {
+              hookSpecificOutput: {
+                hookEventName: "UserPromptSubmit",
+                additionalContext
+              }
             }
-          })}
+          )}
 `
         );
       }
@@ -79986,10 +80734,12 @@ function collectNativeIntegrationStatus(args = []) {
   bindConfigPath(args);
   const config2 = readConfig();
   const env = getDaemonCliEnvironment();
+  const homeDir = (0, import_node_os15.homedir)();
   return NATIVE_SESSION_PROVIDER_CAPABILITIES.map((capability) => ({
     provider: capability.providerKind,
     command: capability.command,
     installed: resolveCliExecutable(capability.command, env) !== null,
+    hooksConfigured: inspectNativeHooksConfigured(capability.providerKind, homeDir),
     hookCoverage: capability.capabilities.lifecycleHooks ? "lifecycle" : capability.capabilities.state === "degraded" ? "notification" : "none",
     transcriptStreaming: capability.capabilities.transcriptDelta,
     inboxReady: Boolean(config2.eventSpoolKey)
@@ -80013,7 +80763,7 @@ function decodeResumeFallbackContext(encoded) {
 }
 
 // src/sandbox.ts
-var import_node_os14 = require("os");
+var import_node_os16 = require("os");
 
 // src/execution-activity-tracker.ts
 var ExecutionActivityTracker = class {
@@ -81310,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_os14.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";
@@ -81610,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_os15 = 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";
@@ -81631,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");
@@ -81661,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>
 `;
@@ -81702,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
@@ -81803,7 +82553,7 @@ WantedBy=default.target
   };
 }
 function currentServicePlan(args, runtime) {
-  const currentPlatform = (0, import_node_os15.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}`);
   }
@@ -81812,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_os15.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 });
@@ -81849,8 +82599,8 @@ function installDaemonService(args = [], runtime) {
   }
   const plan = currentServicePlan(args, runtime);
   if (plan.manifestPath && plan.manifest) {
-    if ((0, import_node_os15.platform)() === "darwin") {
-      (0, import_node_fs25.mkdirSync)((0, import_node_path26.join)((0, import_node_os15.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);
   }
@@ -81872,16 +82622,16 @@ function printDaemonServiceStatus(args = []) {
 
 // src/skills/skill-cli.ts
 var import_promises6 = require("fs/promises");
-var import_node_os16 = 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 homeDirectory = option(options, "--home") ?? (0, import_node_os16.homedir)();
-  const manager = await RuntimeSkillManager.open({ homeDirectory });
+  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");
     const declaredInput = inputPath ? scanSkillsInputSchema.parse(await readProtectedJson(inputPath)) : null;
-    const input2 = declaredInput ? options.includes("--include-configured") ? await resolveSkillScanInput(homeDirectory, declaredInput) : declaredInput : await defaultScanInput(homeDirectory);
+    const input2 = declaredInput ? options.includes("--include-configured") ? await resolveSkillScanInput(homeDirectory2, declaredInput) : declaredInput : await defaultScanInput(homeDirectory2);
     const outcome = await manager.scan(input2);
     process.stdout.write(`${JSON.stringify(outcome)}
 `);
@@ -81908,8 +82658,8 @@ async function runSkillsCommand(args) {
     "Usage: alan-agent skills scan [--input <0600-json>] [--include-configured] [--home <path>] | skills reconcile --manifest <0600-json> [--home <path>] | skills publish --input <0600-json> [--home <path>]"
   );
 }
-async function defaultScanInput(homeDirectory) {
-  return resolveSkillScanInput(homeDirectory, {
+async function defaultScanInput(homeDirectory2) {
+  return resolveSkillScanInput(homeDirectory2, {
     mode: "audit",
     reason: "refresh",
     enabledProviderKinds: [],
@@ -81917,7 +82667,7 @@ async function defaultScanInput(homeDirectory) {
   });
 }
 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) {