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

package/dist/index.cjs

@@ -15240,7 +15240,7 @@ function describeError(error61) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.78";
+var AGENT_VERSION = "0.1.80";
 
 // src/daemon-worktree.ts
 var import_node_child_process3 = require("child_process");
@@ -15576,8 +15576,8 @@ var RESOURCE_CLASS_GC_TIME_MS = {
 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 +35665,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 +35758,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 +35780,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 });
@@ -60269,9 +60298,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;
 }
@@ -72840,9 +72869,29 @@ function failureFromError(error61, paths) {
     stage: "protocol",
     message: "Alan's tool service returned an invalid MCP response.",
     retryable: false,
-    paths
+    paths,
+    diagnostic: describeReadinessError(error61)
   };
 }
+function describeReadinessError(error61) {
+  if (!(error61 instanceof Error)) return String(error61);
+  const parts2 = [];
+  let current = error61;
+  for (let depth = 0; current instanceof Error && depth < 4; depth += 1) {
+    const { name, message } = current;
+    const { code, status } = current;
+    parts2.push(
+      [
+        name,
+        message,
+        code === void 0 ? "" : `code=${String(code)}`,
+        status === void 0 ? "" : `status=${String(status)}`
+      ].filter(Boolean).join(" ")
+    );
+    current = current.cause;
+  }
+  return parts2.join(" <- ");
+}
 async function waitBeforeRetry() {
   await new Promise((resolve15) => setTimeout(resolve15, RETRY_DELAY_MS2));
 }
@@ -73283,7 +73332,8 @@ async function handleAgentExecute(ctx, payload) {
       console.warn("[alan-agent] Alan MCP readiness observed failure", {
         ...correlation,
         code: failure.code,
-        stage: failure.stage
+        stage: failure.stage,
+        ...failure.diagnostic ? { diagnostic: failure.diagnostic } : {}
       });
     }
   });
@@ -74207,7 +74257,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}`;
@@ -74267,12 +74317,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) => {
@@ -74310,6 +74410,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");
@@ -75132,10 +75273,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));
 }
@@ -75742,8 +75883,8 @@ 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);
 }
-async function loadSkillSourceConfig(homeDirectory) {
-  const configDirectory = (0, import_node_path18.join)(homeDirectory, ".alan");
+async function loadSkillSourceConfig(homeDirectory2) {
+  const configDirectory = (0, import_node_path18.join)(homeDirectory2, ".alan");
   const configPath = (0, import_node_path18.join)(configDirectory, "config.toml");
   await (0, import_promises2.mkdir)(configDirectory, { recursive: true, mode: 448 });
   let created = false;
@@ -75759,18 +75900,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"
@@ -75778,7 +75919,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_path18.resolve)((0, import_node_path18.join)(homeDirectory2, ".alan", "skill-sources"));
   const enabledProviders = new Set(declared.enabledProviderKinds ?? []);
   const configured = [];
   for (const source of config2.sources) {
@@ -75802,7 +75943,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");
@@ -75825,7 +75966,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`);
@@ -75833,7 +75974,7 @@ function parseSkillSourceConfig(content, homeDirectory) {
       value2.providers,
       `skills.sources[${index}].providers`
     );
-    const relativeDirectory = import_node_path18.default.relative(homeDirectory, sourcePath);
+    const relativeDirectory = import_node_path18.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);
@@ -75863,14 +76004,14 @@ function requiredSourceId(value2, field) {
   }
   return value2;
 }
-function resolveSkillSourcePath(sourcePath, homeDirectory, pathApi = import_node_path18.default) {
+function resolveSkillSourcePath(sourcePath, homeDirectory2, pathApi = import_node_path18.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;
@@ -78777,17 +78918,10 @@ var log = {
   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_os12.homedir)();
+}
 var MalformedToolConfigError = class extends Error {
 };
 function parseJsonSafe2(content) {
@@ -78848,9 +78982,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_path23.join)(homeDirectory(), ".claude.json");
+  },
+  get guardDir() {
+    return homeDirectory();
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcpServers = config2.mcpServers ?? {};
@@ -78878,8 +79015,12 @@ var claudeAdapter = {
 };
 var codexAdapter = {
   cli: "Codex",
-  configPath: PATHS.codex,
-  guardDir: (0, import_node_path23.join)(HOME, ".codex"),
+  get configPath() {
+    return (0, import_node_path23.join)(homeDirectory(), ".codex", "config.toml");
+  },
+  get guardDir() {
+    return (0, import_node_path23.join)(homeDirectory(), ".codex");
+  },
   merge(existing, servers) {
     let config2 = {};
     if (existing) {
@@ -78920,8 +79061,12 @@ var codexAdapter = {
 };
 var cursorAdapter = {
   cli: "Cursor",
-  configPath: PATHS.cursor,
-  guardDir: (0, import_node_path23.join)(HOME, ".cursor"),
+  get configPath() {
+    return (0, import_node_path23.join)(homeDirectory(), ".cursor", "mcp.json");
+  },
+  get guardDir() {
+    return (0, import_node_path23.join)(homeDirectory(), ".cursor");
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcpServers = config2.mcpServers ?? {};
@@ -78950,8 +79095,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_path23.join)(homeDirectory(), ".gemini", "config", "mcp_config.json");
+    },
+    get guardDir() {
+      return (0, import_node_path23.join)(homeDirectory(), ".gemini", "config");
+    },
     merge(existing, servers) {
       const config2 = parseJsonSafe2(existing);
       const mcpServers = config2.mcpServers ?? {};
@@ -78981,8 +79130,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_path23.join)(homeDirectory(), ".kimi", "mcp.json");
+  },
+  get guardDir() {
+    return (0, import_node_path23.join)(homeDirectory(), ".kimi");
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcpServers = config2.mcpServers ?? {};
@@ -79010,8 +79163,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_path23.join)(homeDirectory(), ".config", "opencode", "opencode.json");
+  },
+  get guardDir() {
+    return (0, import_node_path23.join)(homeDirectory(), ".config", "opencode");
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcp = config2.mcp ?? {};
@@ -79039,8 +79196,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_path23.join)(homeDirectory(), ".factory", "mcp.json");
+  },
+  get guardDir() {
+    return (0, import_node_path23.join)(homeDirectory(), ".factory");
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcpServers = config2.mcpServers ?? {};
@@ -79075,8 +79236,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_path23.join)(homeDirectory(), ".config", "amp", "settings.json");
+  },
+  get guardDir() {
+    return (0, import_node_path23.join)(homeDirectory(), ".config", "amp");
+  },
   merge(existing, servers) {
     const config2 = parseJsonSafe2(existing);
     const mcpServers = config2["amp.mcpServers"] ?? {};
@@ -79182,6 +79347,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)) {
@@ -79202,6 +79438,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 = [];
@@ -79216,6 +79455,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) {
@@ -79224,21 +79464,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 {
@@ -79323,7 +79562,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);
     }
@@ -79371,7 +79612,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,
@@ -79425,6 +79667,10 @@ var McpSyncService = class {
 var import_node_fs22 = require("fs");
 var import_node_os13 = require("os");
 var import_node_path24 = 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",
@@ -79434,15 +79680,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",
@@ -79453,19 +79743,21 @@ 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") {
     const environmentPrefix2 = environment.map(([key, value2]) => `$env:${key}=${powershellQuote(value2)}`).join("; ");
@@ -79486,7 +79778,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_os13.homedir)(),
+    nodeExecutable: input2.nodeExecutable ?? process.execPath,
+    cliEntry,
+    environment: input2.environment,
+    platform: input2.platform ?? (0, import_node_os13.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"));
@@ -79498,78 +79823,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) {
+  const serialized = `${JSON.stringify(settings, null, 2)}
+`;
+  if ((0, import_node_fs22.existsSync)(path2) && (0, import_node_fs22.readFileSync)(path2, "utf8") === serialized) return false;
   (0, import_node_fs22.mkdirSync)((0, import_node_path24.dirname)(path2), { recursive: true, mode: 448 });
   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_path24.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 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 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_path24.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_os13.homedir)()) {
+  return removeNestedCommandHooks((0, import_node_path24.join)(homeDir, ".claude", "settings.json"), "Claude");
+}
+function reconcileCodexNativeHooks(input2 = {}) {
+  const runtime = resolveRuntime(input2);
+  return reconcileNestedCommandHooks({
+    path: (0, import_node_path24.join)(runtime.homeDir, ".codex", "hooks.json"),
+    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_os13.homedir)()) {
+  return removeNestedCommandHooks((0, import_node_path24.join)(homeDir, ".codex", "hooks.json"), "Codex");
+}
+function reconcileCopilotNativeHooks(input2 = {}) {
+  const runtime = resolveRuntime(input2);
+  const path2 = (0, import_node_path24.join)(runtime.homeDir, ".copilot", "hooks", "alan-native-session.json");
+  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 settings = readSettings(settingsPath);
+  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_os13.homedir)()) {
+  const path2 = (0, import_node_path24.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_path24.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 CLAUDE_HOOK_EVENTS) {
+  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_os13.homedir)()) {
+  const path2 = (0, import_node_path24.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_path24.join)(runtime.homeDir, ".kimi-code", "config.toml");
+  const current = (0, import_node_fs22.existsSync)(path2) ? (0, import_node_fs22.readFileSync)(path2, "utf8") : "";
+  const userContent = withoutMarkedSection(current, ALAN_KIMI_HOOKS_START, ALAN_KIMI_HOOKS_END);
+  const content = `${userContent.trimEnd()}${userContent.trim() ? "\n\n" : ""}${kimiHookSection(runtime)}
+`;
+  return writeTextFile(path2, content);
+}
+function removeKimiNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
+  const path2 = (0, import_node_path24.join)(homeDir, ".kimi-code", "config.toml");
+  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_path24.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_os13.homedir)()) {
+  const path2 = (0, import_node_path24.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_path24.join)(runtime.homeDir, ".config", "opencode", "plugins", "alan-native-session.js");
+  if ((0, import_node_fs22.existsSync)(path2) && !(0, import_node_fs22.readFileSync)(path2, "utf8").includes(ALAN_OPENCODE_PLUGIN_MARKER)) {
+    throw new Error(`Refusing to overwrite non-Alan OpenCode plugin at ${path2}`);
+  }
+  const source = opencodePluginSource(runtime);
+  if ((0, import_node_fs22.existsSync)(path2) && (0, import_node_fs22.readFileSync)(path2, "utf8") === source) return false;
+  (0, import_node_fs22.mkdirSync)((0, import_node_path24.dirname)(path2), { recursive: true, mode: 448 });
+  const temporary = `${path2}.${process.pid}.tmp`;
+  (0, import_node_fs22.writeFileSync)(temporary, source, { mode: 384 });
+  (0, import_node_fs22.renameSync)(temporary, path2);
+  return true;
+}
+function removeOpencodeNativePlugin(homeDir = (0, import_node_os13.homedir)()) {
+  const path2 = (0, import_node_path24.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js");
+  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_os13.homedir)()) {
+  switch (providerKind) {
+    case "claude_cli":
+      return configFileContainsMarker((0, import_node_path24.join)(homeDir, ".claude", "settings.json"), ALAN_HOOK_MARKER);
+    case "codex_app_server":
+      return configFileContainsMarker((0, import_node_path24.join)(homeDir, ".codex", "hooks.json"), ALAN_HOOK_MARKER);
+    case "copilot_cli":
+      return configFileContainsMarker(
+        (0, import_node_path24.join)(homeDir, ".copilot", "hooks", "alan-native-session.json"),
+        ALAN_HOOK_MARKER
+      );
+    case "cursor_agent_cli":
+      return configFileContainsMarker((0, import_node_path24.join)(homeDir, ".cursor", "hooks.json"), ALAN_HOOK_MARKER);
+    case "kimi_cli":
+      return configFileContainsMarker(
+        (0, import_node_path24.join)(homeDir, ".kimi-code", "config.toml"),
+        ALAN_KIMI_HOOKS_START
+      );
+    case "grok_cli":
+      return configFileContainsMarker(
+        (0, import_node_path24.join)(homeDir, ".grok", "hooks", "alan-native-session.json"),
+        ALAN_HOOK_MARKER
+      );
+    case "opencode_cli":
+      return configFileContainsMarker(
+        (0, import_node_path24.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js"),
+        ALAN_OPENCODE_PLUGIN_MARKER
+      );
+    default:
+      return false;
+  }
+}
 
 // src/integration-cli.ts
 function alanMcpServers(apiUrl) {
@@ -79580,12 +80190,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)}
 `);
@@ -79597,23 +80236,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;
   }
@@ -79695,6 +80337,7 @@ function omitUndefined(record2) {
 // src/native-hook-command.ts
 var import_node_crypto19 = require("crypto");
 var import_node_fs23 = require("fs");
+var import_node_os14 = require("os");
 var import_node_path25 = require("path");
 
 // src/native-session.ts
@@ -79727,28 +80370,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",
@@ -79761,22 +80440,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",
@@ -79826,6 +80553,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];
@@ -79833,19 +80571,77 @@ function nonNegativeIntegerField(payload, ...names) {
   }
   return void 0;
 }
+function resolveCodexSessionIdFromTranscriptPath(transcriptPath) {
+  const fileName = (0, import_node_path25.basename)(transcriptPath);
+  const match = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i.exec(
+    fileName
+  );
+  return match?.[1];
+}
+function resolveKimiTranscriptPath(externalSessionId, kimiHomeDir = process.env.KIMI_CODE_HOME?.trim() || (0, import_node_path25.join)((0, import_node_os14.homedir)(), ".kimi-code")) {
+  if ((0, import_node_path25.basename)(externalSessionId) !== externalSessionId) return void 0;
+  const sessionsDir = (0, import_node_path25.join)(kimiHomeDir, "sessions");
+  if (!(0, import_node_fs23.existsSync)(sessionsDir)) return void 0;
+  for (const workspace of (0, import_node_fs23.readdirSync)(sessionsDir, { withFileTypes: true })) {
+    if (!workspace.isDirectory()) continue;
+    const transcriptPath = (0, import_node_path25.join)(
+      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",
@@ -79853,20 +80649,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"),
+    ...(eventType === "subagent_start" || eventType === "subagent_end") && parentSessionId ? { parentExternalSessionId: parentSessionId } : {},
     ...cwd ? { cwd: (0, import_node_path25.resolve)(cwd) } : {},
     ...transcriptPath ? { transcriptPath: (0, import_node_path25.resolve)(transcriptPath) } : {},
     ...cursor ? { sourceCursor: cursor } : {},
-    providerPayload: input2.payload
+    providerPayload
   };
 }
 function normalizeHookEvent(raw) {
@@ -79875,6 +80681,8 @@ function normalizeHookEvent(raw) {
     case "session_start":
       return "session_start";
     case "userpromptsubmit":
+    case "userpromptsubmitted":
+    case "beforesubmitprompt":
     case "user_prompt":
       return "user_prompt";
     case "subagentstart":
@@ -79887,8 +80695,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";
   }
@@ -79933,21 +80752,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
+              }
             }
-          })}
+          )}
 `
         );
       }
@@ -79965,10 +80797,12 @@ function collectNativeIntegrationStatus(args = []) {
   bindConfigPath(args);
   const config2 = readConfig();
   const env = getDaemonCliEnvironment();
+  const homeDir = (0, import_node_os14.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)
@@ -79992,7 +80826,7 @@ function decodeResumeFallbackContext(encoded) {
 }
 
 // src/sandbox.ts
-var import_node_os14 = require("os");
+var import_node_os15 = require("os");
 
 // src/execution-activity-tracker.ts
 var ExecutionActivityTracker = class {
@@ -80510,6 +81344,9 @@ var WebPresenter = class {
       id: (0, import_node_crypto20.randomUUID)(),
       title: APPLICATION_PROBLEM_TITLES[input2.code],
       detail: input2.message,
+      // The schema's slot for the technical cause, so the problem carries it
+      // without putting an SDK error message in front of the person.
+      ...input2.diagnostic ? { diagnosticsRef: input2.diagnostic } : {},
       occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
       severity: "terminal",
       scope: {
@@ -81095,9 +81932,10 @@ var WSClient = class {
 
 // src/sandbox.ts
 var RequiredToolsUnavailableError = class extends Error {
-  constructor(code, message) {
+  constructor(code, message, diagnostic) {
     super(message);
     this.code = code;
+    this.diagnostic = diagnostic;
     this.name = "RequiredToolsUnavailableError";
   }
 };
@@ -81285,7 +82123,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_os15.homedir)() });
   let lastProviderSessionId = config2.providerSessionId;
   let resumeFallbackContext = config2.resumeFallbackContext;
   let activeBackendKind = config2.backendKind || "claude_cli";
@@ -81370,10 +82208,17 @@ async function runSandbox(config2) {
             lifecycle.warn("sandbox_agent_mcp_readiness_failed", {
               backendKind: activeBackendKind,
               code: readiness.code,
+              // The protocol branch cannot describe itself; without this the
+              // event names a category and nothing else.
+              ...readiness.diagnostic ? { diagnostic: readiness.diagnostic } : {},
               stage: readiness.stage,
               retryable: readiness.retryable
             });
-            throw new RequiredToolsUnavailableError(readiness.code, readiness.message);
+            throw new RequiredToolsUnavailableError(
+              readiness.code,
+              readiness.message,
+              readiness.diagnostic
+            );
           }
         } else if (currentRunId ?? config2.runId) {
           lifecycle.warn("sandbox_agent_mcp_contract_missing", {
@@ -81464,7 +82309,11 @@ async function runSandbox(config2) {
           error: errorMessage
         };
         if (error61 instanceof RequiredToolsUnavailableError) {
-          presenter.onApplicationError({ code: error61.code, message: error61.message });
+          presenter.onApplicationError({
+            code: error61.code,
+            message: error61.message,
+            ...error61.diagnostic ? { diagnostic: error61.diagnostic } : {}
+          });
         } else {
           presenter.onError(errorMessage, false);
         }
@@ -81574,7 +82423,7 @@ 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_os16 = require("os");
 var import_node_path26 = require("path");
 var SERVICE_LABEL = "ai.tryalan.agent";
 var SYSTEMD_UNIT = "alan-agent.service";
@@ -81767,7 +82616,7 @@ WantedBy=default.target
   };
 }
 function currentServicePlan(args, runtime) {
-  const currentPlatform = (0, import_node_os15.platform)();
+  const currentPlatform = (0, import_node_os16.platform)();
   if (currentPlatform !== "darwin" && currentPlatform !== "linux" && currentPlatform !== "win32") {
     throw new Error(`Daemon service installation is not supported on ${currentPlatform}`);
   }
@@ -81776,7 +82625,7 @@ 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_os16.homedir)(),
     nodeExecutable: runtime?.executable ?? process.execPath,
     cliEntry: (0, import_node_path26.resolve)(cliEntry),
     profile,
@@ -81813,8 +82662,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_os16.platform)() === "darwin") {
+      (0, import_node_fs25.mkdirSync)((0, import_node_path26.join)((0, import_node_os16.homedir)(), ".alan", "agent", "logs"), { recursive: true, mode: 448 });
     }
     writeManifest(plan.manifestPath, plan.manifest);
   }
@@ -81836,16 +82685,16 @@ function printDaemonServiceStatus(args = []) {
 
 // src/skills/skill-cli.ts
 var import_promises6 = require("fs/promises");
-var import_node_os16 = require("os");
+var import_node_os17 = require("os");
 var import_node_path27 = 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_os17.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)}
 `);
@@ -81872,8 +82721,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: [],