@alan-ai-hq/agent-manager 0.1.90 → 0.1.92

package/dist/index.cjs

@@ -3404,7 +3404,7 @@ var require_websocket = __commonJS({
     var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes13, createHash: createHash17 } = require("crypto");
+    var { randomBytes: randomBytes13, createHash: createHash18 } = require("crypto");
     var { Duplex, Readable: Readable2 } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -4061,7 +4061,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash17("sha1").update(key + GUID).digest("base64");
+        const digest = createHash18("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -4428,7 +4428,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = require("events");
     var http2 = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash17 } = require("crypto");
+    var { createHash: createHash18 } = require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -4725,7 +4725,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash17("sha1").update(key + GUID).digest("base64");
+        const digest = createHash18("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -15451,7 +15451,7 @@ function describeError(error61) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.90";
+var AGENT_VERSION = "0.1.92";
 
 // src/daemon-worktree.ts
 var import_node_child_process3 = require("child_process");
@@ -36003,6 +36003,42 @@ var import_fs = require("fs");
 var import_os = require("os");
 var import_path = require("path");
 
+// ../shared/dist/utils/workflow-tools-filter.js
+var WORKFLOW_ALWAYS_ALLOWED_BUILTIN_TOOLS = [
+  "search_context",
+  "create_test_report",
+  "create_plan",
+  "create_document_artifact",
+  "upsert_prototype_version",
+  "list_artifacts",
+  "get_artifact",
+  "list_prototypes",
+  "get_prototype"
+];
+function createWorkflowToolsFilter(workflowTools) {
+  const hasFilter = !!workflowTools && workflowTools.length > 0;
+  if (!hasFilter) {
+    return {
+      hasFilter: false,
+      isMcpServerAllowed: () => true,
+      resolveAllowedBuiltinTools: () => null
+    };
+  }
+  const tools = workflowTools;
+  const mcpServerIds = new Set(tools.filter((t) => t.type === "mcp").map((t) => t.id));
+  const builtinToolIds = tools.filter((t) => t.type === "builtin" || t.type === "integration").map((t) => t.id);
+  return {
+    hasFilter: true,
+    isMcpServerAllowed: (serverName) => mcpServerIds.has(serverName),
+    resolveAllowedBuiltinTools: () => {
+      const merged = new Set(builtinToolIds);
+      for (const id of WORKFLOW_ALWAYS_ALLOWED_BUILTIN_TOOLS)
+        merged.add(id);
+      return [...merged];
+    }
+  };
+}
+
 // ../shared/dist/agent/agent-definitions.js
 var COORDINATOR_PROMPT = `## You are the Orchestrator
 
@@ -36490,6 +36526,34 @@ function buildAlanMcpServers(registration) {
     }
   };
 }
+var ALAN_RUN_REFERENCE_ENV = "ALAN_RUN_REFERENCE";
+var MCP_CONFIG_KEY = /^[A-Za-z0-9_-]+$/;
+function isExternalMcpServerName(name) {
+  return MCP_CONFIG_KEY.test(name) && name !== "alan";
+}
+function isMcpConfigKey(name) {
+  return MCP_CONFIG_KEY.test(name);
+}
+var CURSOR_RUN_REFERENCE_HEADER_VALUE = `\${env:${ALAN_RUN_REFERENCE_ENV}}`;
+function toCursorMcpServers(src) {
+  const out = {};
+  for (const [name, raw] of Object.entries(src)) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const s = raw;
+    const isHttp = typeof s.type === "string" && s.type === "http" || typeof s.url === "string";
+    if (!isHttp) {
+      out[name] = s;
+      continue;
+    }
+    const headers = Object.fromEntries(Object.entries(s.headers ?? {}).filter(([key]) => key.toLowerCase() !== "x-alan-run-reference"));
+    out[name] = {
+      ...s,
+      headers: { ...headers, "x-alan-run-reference": CURSOR_RUN_REFERENCE_HEADER_VALUE }
+    };
+  }
+  return out;
+}
 function toFactoryMcpServers(src) {
   const out = {};
   for (const [name, raw] of Object.entries(src)) {
@@ -36634,7 +36698,10 @@ function renderAlanMcpConfigFiles(mcpServers, home) {
       mergeJsonKey: "mcpServers"
     },
     { path: `${home}/.codex/config.toml`, content: toCodexMcpToml(mcpServers) },
-    { path: `${home}/.cursor/mcp.json`, content: JSON.stringify({ mcpServers }) },
+    {
+      path: `${home}/.cursor/mcp.json`,
+      content: JSON.stringify({ mcpServers: toCursorMcpServers(mcpServers) })
+    },
     {
       path: `${home}/.factory/mcp.json`,
       content: JSON.stringify({ mcpServers: toFactoryMcpServers(mcpServers) })
@@ -38302,6 +38369,7 @@ var import_os4 = require("os");
 var import_path5 = require("path");
 var import_url = require("url");
 var import_crypto4 = require("crypto");
+var import_crypto5 = require("crypto");
 var import_fs6 = require("fs");
 var import_os5 = require("os");
 var import_path6 = require("path");
@@ -38319,14 +38387,16 @@ var import_path9 = require("path");
 var import_fs10 = require("fs");
 var import_os9 = require("os");
 var import_path10 = require("path");
-var import_crypto5 = require("crypto");
+var import_crypto6 = require("crypto");
 var import_readline2 = require("readline");
 var import_url2 = require("url");
-var import_crypto6 = require("crypto");
+var import_crypto7 = require("crypto");
 var import_fs11 = require("fs");
 var import_path11 = require("path");
-var ALAN_RUN_REFERENCE_ENV = "ALAN_RUN_REFERENCE";
 var ALAN_MCP_URL_ENV = "ALAN_MCP_URL";
+function deliversRunReferenceViaEnv(backendKind) {
+  return backendKind === "cursor_agent_cli";
+}
 var ALAN_AGENT_ENTRY_ENV = "ALAN_AGENT_ENTRY";
 var ALAN_NODE_EXECUTABLE_ENV = "ALAN_NODE_EXECUTABLE";
 function usesProcessLocalManagedMcp(backendKind) {
@@ -41091,6 +41161,65 @@ function createAntigravityCliBackend(command = "agy", defaultArgs = []) {
     }
   };
 }
+function isWorkflowRun(config2) {
+  return Boolean(config2.workflowId || config2.workflowExecutionId);
+}
+function selectExternalMcpServers(config2) {
+  const selected = {};
+  const filter = isWorkflowRun(config2) ? createWorkflowToolsFilter(config2.workflowTools) : null;
+  if (filter && !filter.hasFilter) return selected;
+  for (const [name, server] of Object.entries(config2.externalMcpServers ?? {})) {
+    if (!isExternalMcpServerName(name)) continue;
+    if (filter && !filter.isMcpServerAllowed(name)) continue;
+    selected[name] = server;
+  }
+  return selected;
+}
+function headerEnvName(server, header) {
+  const fingerprint = (0, import_crypto5.createHash)("sha256").update(`${server}\0${header}`).digest("hex").slice(0, 12).toUpperCase();
+  return `ALAN_MCP_HEADER_${fingerprint}`;
+}
+function planExternalMcpDelivery(config2, processEnv) {
+  const verbatim = selectExternalMcpServers(config2);
+  const servers = {};
+  const env = {};
+  for (const [name, server] of Object.entries(verbatim)) {
+    if (server.url && server.type !== "stdio") {
+      const headerEnv = {};
+      for (const [header, value2] of Object.entries(server.headers ?? {})) {
+        if (!isMcpConfigKey(header)) continue;
+        const variable = headerEnvName(name, header);
+        env[variable] = value2;
+        headerEnv[header] = variable;
+      }
+      servers[name] = {
+        type: server.type === "sse" ? "sse" : "http",
+        url: server.url,
+        ...Object.keys(headerEnv).length ? { headerEnv } : {}
+      };
+    } else if (server.command) {
+      const envKeys = [];
+      for (const [key, value2] of Object.entries(server.env ?? {})) {
+        if (!isMcpConfigKey(key)) continue;
+        if (key in processEnv || key in env && env[key] !== value2) {
+          console.warn(
+            `[external-mcp] Not forwarding env ${key} for MCP server ${name}: it is already set for this run`
+          );
+          continue;
+        }
+        env[key] = value2;
+        envKeys.push(key);
+      }
+      servers[name] = {
+        type: "stdio",
+        command: server.command,
+        ...server.args?.length ? { args: server.args } : {},
+        ...envKeys.length ? { envKeys } : {}
+      };
+    }
+  }
+  return { servers, env, verbatim };
+}
 function resolveClaudeHome(env, variant = "claude") {
   if (variant === "supatest") {
     return (0, import_path6.join)((0, import_os5.homedir)(), ".supatest", "claude-internal");
@@ -41525,22 +41654,40 @@ function buildClaudeModelArg(baseModel, selectedContextWindow) {
   if (selectedContextWindow === "1m") return `${baseModel}[1m]`;
   return baseModel;
 }
-function buildClaudeManagedMcpArgs(registration, env) {
-  const entry = env[ALAN_AGENT_ENTRY_ENV]?.trim() || process.argv[1];
-  const node2 = env[ALAN_NODE_EXECUTABLE_ENV]?.trim() || process.execPath;
-  if (!entry) throw new Error("Cannot resolve the Alan MCP proxy entrypoint");
+function buildClaudeManagedMcpArgs(registration, options = {}) {
+  const mcpServers = {};
+  for (const [name, server] of Object.entries(options.externalServers ?? {})) {
+    if (server.type === "stdio") {
+      mcpServers[name] = {
+        type: "stdio",
+        command: server.command,
+        ...server.args?.length ? { args: server.args } : {},
+        ...server.envKeys?.length ? { env: Object.fromEntries(server.envKeys.map((key) => [key, `\${${key}}`])) } : {}
+      };
+    } else {
+      mcpServers[name] = {
+        type: server.type,
+        url: server.url,
+        ...server.headerEnv ? {
+          headers: Object.fromEntries(
+            Object.entries(server.headerEnv).map(([header, variable]) => [
+              header,
+              `\${${variable}}`
+            ])
+          )
+        } : {}
+      };
+    }
+  }
+  mcpServers.alan = {
+    type: "http",
+    url: registration.url,
+    headers: { "x-alan-run-reference": `\${${ALAN_RUN_REFERENCE_ENV}}` }
+  };
   return [
-    "--strict-mcp-config",
+    ...options.strict ? ["--strict-mcp-config"] : [],
     "--mcp-config",
-    JSON.stringify({
-      mcpServers: {
-        [managedMcpServerName(registration)]: {
-          type: "stdio",
-          command: node2,
-          args: [entry, "mcp-proxy"]
-        }
-      }
-    })
+    JSON.stringify({ mcpServers })
   ];
 }
 function createClaudeCliBackend(command = "claude", defaultArgs = []) {
@@ -41549,11 +41696,12 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
     supportTier: "structured",
     async run(context) {
       const managedRegistration = context.config.alanMcp;
+      const externalMcp = managedRegistration ? planExternalMcpDelivery(context.config, context.env) : void 0;
       const runContext = managedRegistration ? {
         ...context,
         env: {
           ...context.env,
-          [ALAN_MCP_URL_ENV]: managedRegistration.url,
+          ...externalMcp?.env,
           [ALAN_RUN_REFERENCE_ENV]: requireManagedRunReference(managedRegistration)
         }
       } : context;
@@ -41567,7 +41715,12 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
         getClaudePermissionMode(context.config)
       ];
       if (managedRegistration) {
-        args.push(...buildClaudeManagedMcpArgs(managedRegistration, runContext.env));
+        args.push(
+          ...buildClaudeManagedMcpArgs(managedRegistration, {
+            strict: isWorkflowRun(context.config),
+            externalServers: externalMcp?.servers
+          })
+        );
       }
       const disallowedTools = getClaudeDisallowedTools(context.config);
       if (disallowedTools.length > 0) {
@@ -42795,27 +42948,60 @@ function buildCodexEffortArgs(selectedEffortLevel, options) {
   return ["-c", `model_reasoning_effort=${level}`];
 }
 var CODEX_STARTUP_TIMEOUT_MS = 3e5;
-function buildCodexManagedMcpArgs(registration) {
-  const serverName = managedMcpServerName(registration);
+var ALAN_MCP_STARTUP_TIMEOUT_SEC = 30;
+function buildCodexManagedMcpArgs(registration, options = {}) {
   return [
-    "--ignore-user-config",
+    // Workflow runs keep the exclusive config: their tool set is a policy,
+    // not the user's own server list.
+    ...options.strict ? ["--ignore-user-config"] : [],
+    "-c",
+    `mcp_servers.alan.url=${JSON.stringify(registration.url)}`,
     "-c",
-    `mcp_servers.${serverName}.url=${JSON.stringify(registration.url)}`,
+    `mcp_servers.alan.env_http_headers.x-alan-run-reference=${JSON.stringify(ALAN_RUN_REFERENCE_ENV)}`,
     "-c",
-    `mcp_servers.${serverName}.env_http_headers.x-alan-run-reference=${JSON.stringify(ALAN_RUN_REFERENCE_ENV)}`
+    "mcp_servers.alan.required=true",
+    "-c",
+    `mcp_servers.alan.startup_timeout_sec=${ALAN_MCP_STARTUP_TIMEOUT_SEC}`
   ];
 }
+function buildCodexExternalMcpArgs(servers) {
+  const args = [];
+  for (const [name, server] of Object.entries(servers ?? {})) {
+    const key = `mcp_servers.${name}`;
+    if (server.type === "stdio") {
+      args.push("-c", `${key}.command=${JSON.stringify(server.command)}`);
+      if (server.args?.length) args.push("-c", `${key}.args=${JSON.stringify(server.args)}`);
+      if (server.envKeys?.length) {
+        args.push("-c", `${key}.env_vars=${JSON.stringify(server.envKeys)}`);
+      }
+    } else {
+      if (server.type === "sse") continue;
+      args.push("-c", `${key}.url=${JSON.stringify(server.url)}`);
+      for (const [header, variable] of Object.entries(server.headerEnv ?? {})) {
+        args.push("-c", `${key}.env_http_headers.${header}=${JSON.stringify(variable)}`);
+      }
+    }
+  }
+  return args;
+}
 function createCodexRuntimeBackend(command = "codex", defaultArgs = []) {
   return {
     kind: "codex_app_server",
     supportTier: "structured",
     async run(context) {
       const managedRegistration = context.config.alanMcp;
-      const managedMcpArgs = managedRegistration ? buildCodexManagedMcpArgs(managedRegistration) : [];
+      const externalMcp = managedRegistration ? planExternalMcpDelivery(context.config, context.env) : void 0;
+      const managedMcpArgs = managedRegistration ? [
+        ...buildCodexManagedMcpArgs(managedRegistration, {
+          strict: isWorkflowRun(context.config)
+        }),
+        ...buildCodexExternalMcpArgs(externalMcp?.servers)
+      ] : [];
       const runContext = managedRegistration ? {
         ...context,
         env: {
           ...context.env,
+          ...externalMcp?.env,
           [ALAN_RUN_REFERENCE_ENV]: requireManagedRunReference(managedRegistration)
         }
       } : context;
@@ -43776,6 +43962,13 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
         context.cwd
       );
       const approveMcps = context.config.alanMcp ? await cliSupportsFlag(command, "--approve-mcps", context.env) : false;
+      const runContext = context.config.alanMcp ? {
+        ...context,
+        env: {
+          ...context.env,
+          [ALAN_RUN_REFERENCE_ENV]: requireManagedRunReference(context.config.alanMcp)
+        }
+      } : context;
       try {
         return await createGenericCliBackend({
           kind: "cursor_agent_cli",
@@ -43853,7 +44046,7 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
             return appendImagePathReferences(prompt, imageFiles);
           },
           parseStructuredLine: parseCursorStructuredLine
-        }).run(context);
+        }).run(runContext);
       } finally {
         cleanup();
       }
@@ -44909,6 +45102,28 @@ function resolveKimiCliModelArg(model) {
   if (trimmed.startsWith("claude-")) return void 0;
   return trimmed;
 }
+function buildKimiMcpConfig(registration, externalServers = {}) {
+  const mcpServers = {};
+  for (const [name, server] of Object.entries(externalServers)) {
+    if (server.url && server.type !== "stdio") {
+      mcpServers[name] = {
+        url: server.url,
+        ...server.headers ? { headers: server.headers } : {}
+      };
+    } else if (server.command) {
+      mcpServers[name] = {
+        command: server.command,
+        ...server.args?.length ? { args: server.args } : {},
+        ...server.env ? { env: server.env } : {}
+      };
+    }
+  }
+  mcpServers[managedMcpServerName(registration)] = {
+    url: registration.url,
+    headers: { "x-alan-run-reference": requireManagedRunReference(registration) }
+  };
+  return { mcpServers };
+}
 function createKimiCliBackend(command = "kimi-cli", defaultArgs = []) {
   return {
     kind: "kimi_cli",
@@ -44920,14 +45135,9 @@ function createKimiCliBackend(command = "kimi-cli", defaultArgs = []) {
       if (registration && mcpConfigPath) {
         (0, import_fs9.writeFileSync)(
           mcpConfigPath,
-          JSON.stringify({
-            mcpServers: {
-              [managedMcpServerName(registration)]: {
-                url: registration.url,
-                headers: { "x-alan-run-reference": requireManagedRunReference(registration) }
-              }
-            }
-          }),
+          JSON.stringify(
+            buildKimiMcpConfig(registration, selectExternalMcpServers(context.config))
+          ),
           { mode: 384 }
         );
       }
@@ -45454,7 +45664,7 @@ function leaseKeyFor(context) {
   if (!conversationId) return null;
   const runReference = context.config.alanMcp?.headers?.["x-alan-run-reference"];
   if (!runReference) return `conv:${conversationId}`;
-  const fingerprint = (0, import_crypto5.createHash)("sha256").update(runReference).digest("hex").slice(0, 16);
+  const fingerprint = (0, import_crypto6.createHash)("sha256").update(runReference).digest("hex").slice(0, 16);
   return `conv:${conversationId}|mcp:${fingerprint}`;
 }
 function isLeaseUsable(lease) {
@@ -46479,8 +46689,10 @@ var BaseMachineAgent = class _BaseMachineAgent {
    */
   async beginMcpConfigCriticalSection(backend, context) {
     const runHeaders = context.config.alanMcp?.headers;
-    if (!runHeaders || usesProcessLocalManagedMcp(backend.kind)) return () => {
-    };
+    if (!runHeaders || usesProcessLocalManagedMcp(backend.kind) || deliversRunReferenceViaEnv(backend.kind)) {
+      return () => {
+      };
+    }
     const releaseGate = await acquireMcpConfigWriteGate();
     try {
       const writtenClis = await syncAlanMcpSessionHeaders({
@@ -46493,7 +46705,11 @@ var BaseMachineAgent = class _BaseMachineAgent {
         void this.presenter.onLog(`Synced Alan MCP session headers to ${writtenClis.join(", ")}`);
       }
     } catch (error61) {
-      console.warn("[base-machine-agent] Failed to sync MCP session headers", error61);
+      releaseGate();
+      throw new Error(
+        `Alan could not write this run's MCP credential for ${backend.kind}, so the provider was not started: ${error61 instanceof Error ? error61.message : String(error61)}`,
+        { cause: error61 }
+      );
     }
     return releaseGate;
   }
@@ -46988,7 +47204,7 @@ function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName, op
     const { width, height } = readImageDimensions2(buffer, mimeType);
     images.push({
       type: "generated_image",
-      id: (0, import_crypto6.randomUUID)(),
+      id: (0, import_crypto7.randomUUID)(),
       filename: (0, import_path11.basename)(path2),
       mimeType,
       size: buffer.length,
@@ -46996,7 +47212,7 @@ function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName, op
       height,
       data: buffer.toString("base64"),
       sourcePath: path2,
-      sourceHash: (0, import_crypto6.createHash)("sha256").update(buffer).digest("hex"),
+      sourceHash: (0, import_crypto7.createHash)("sha256").update(buffer).digest("hex"),
       toolId,
       ts: Date.now()
     });
@@ -47028,7 +47244,7 @@ function extractSessionMediaFromToolResult(toolId, content, cwd, toolName, optio
     media.push({
       type: "session_media",
       kind,
-      id: (0, import_crypto6.randomUUID)(),
+      id: (0, import_crypto7.randomUUID)(),
       filename: (0, import_path11.basename)(path2),
       mimeType,
       size: buffer.length,
@@ -47036,7 +47252,7 @@ function extractSessionMediaFromToolResult(toolId, content, cwd, toolName, optio
       height: dimensions?.height,
       data: buffer.toString("base64"),
       sourcePath: path2,
-      sourceHash: (0, import_crypto6.createHash)("sha256").update(buffer).digest("hex"),
+      sourceHash: (0, import_crypto7.createHash)("sha256").update(buffer).digest("hex"),
       toolId,
       ts: Date.now()
     });
@@ -56800,7 +57016,12 @@ async function ensureAlanMcpRegistered(backendKind, registration, home = (0, imp
         releaseLock();
       }
     }
-    const fileOk = paths.length > 0 && paths.every((p) => registrationsMatch(readAlanMcpRegistration(p), registration));
+    const fileOk = files.length > 0 && files.every(
+      (file2) => registrationsMatch(
+        readAlanMcpRegistration(file2.path),
+        parseAlanMcpRegistration(file2.path, file2.content) ?? registration
+      )
+    );
     if (!fileOk) {
       const issue2 = {
         code: "mcp_config_repair_required",
@@ -56974,7 +57195,8 @@ function hasUsableRegistrationCredential(headers) {
   const normalized = new Map(
     Object.entries(headers).map(([name, value2]) => [name.toLowerCase(), value2.trim()])
   );
-  return Boolean(normalized.get("x-alan-run-reference") || normalized.get("authorization"));
+  const reference = normalized.get("x-alan-run-reference") ?? "";
+  return Boolean(reference && !reference.startsWith("${") || normalized.get("authorization"));
 }
 function readAlanMcpRegistration(path2) {
   return parseAlanMcpRegistration(path2, (0, import_node_fs16.readFileSync)(path2, "utf8"));
@@ -75266,6 +75488,7 @@ async function handleAgentExecute(ctx, payload) {
     prMeta: payload.prMeta,
     conversationId: payload.conversationId,
     alanMcp: payload.alanMcp,
+    externalMcpServers: payload.externalMcpServers,
     taskId: payload.taskId ?? payload.taskMeta?.id,
     teamId: payload.teamId,
     currentUser: payload.currentUser,
@@ -82145,345 +82368,966 @@ function runMcpIntegrationCommand(args, options = {}) {
   throw new Error(`Unknown integrations action: ${action}`);
 }
 
-// src/lifecycle-logger.ts
-var AgentLifecycleLogger = class _AgentLifecycleLogger {
-  context;
-  constructor(context = {}) {
-    this.context = normalizeContext(context);
-  }
-  setContext(context) {
-    this.context = normalizeContext({ ...this.context, ...context });
-  }
-  child(context) {
-    return new _AgentLifecycleLogger({ ...this.context, ...context });
-  }
-  debug(event, fields = {}) {
-    this.log("debug", event, fields);
-  }
-  info(event, fields = {}) {
-    this.log("info", event, fields);
-  }
-  warn(event, fields = {}) {
-    this.log("warn", event, fields);
-  }
-  error(event, fields = {}) {
-    this.log("error", event, fields);
-  }
-  log(level, event, fields) {
-    const record2 = omitUndefined({
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      level,
-      component: "agent-manager",
-      event,
-      ...this.context,
-      ...normalizeFields(fields)
-    });
-    console[level](JSON.stringify(record2));
-  }
-};
-function lifecycleContextFromEnv(env) {
-  return normalizeContext({
-    taskId: env.ALAN_TASK_ID,
-    conversationId: env.ALAN_SESSION_ID,
-    runId: env.ALAN_RUN_ID,
-    sandboxId: env.ALAN_SANDBOX_ID,
-    provider: env.ALAN_SANDBOX_PROVIDER,
-    backendKind: env.ALAN_BACKEND_KIND,
-    agentVersion: AGENT_VERSION
-  });
-}
-function normalizeContext(context) {
-  return omitUndefined({
-    ...context,
-    agentVersion: context.agentVersion ?? AGENT_VERSION
-  });
+// src/service-manager.ts
+var import_node_child_process9 = require("child_process");
+var import_node_fs25 = require("fs");
+var import_node_os16 = require("os");
+var import_node_path27 = require("path");
+var SERVICE_LABEL = "ai.tryalan.agent";
+var SYSTEMD_UNIT = "alan-agent.service";
+var WINDOWS_TASK = "Alan Agent";
+function xml(value2) {
+  return value2.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
-function normalizeFields(fields) {
-  const normalized = {};
-  for (const [key, value2] of Object.entries(fields)) {
-    if (value2 instanceof Error) {
-      normalized[key] = {
-        name: value2.name,
-        message: value2.message,
-        stack: value2.stack
-      };
-    } else {
-      normalized[key] = value2;
-    }
-  }
-  return normalized;
+function systemdArg(value2) {
+  return `"${value2.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
 }
-function omitUndefined(record2) {
-  return Object.fromEntries(Object.entries(record2).filter(([, value2]) => value2 !== void 0));
+function powershellLiteral(value2) {
+  return `'${value2.replaceAll("'", "''")}'`;
 }
-
-// ../../node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
-var __create3 = Object.create;
-var __defProp3 = Object.defineProperty;
-var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames3 = Object.getOwnPropertyNames;
-var __getProtoOf3 = Object.getPrototypeOf;
-var __hasOwnProp3 = Object.prototype.hasOwnProperty;
-var __commonJSMin2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __exportAll2 = (all, symbols) => {
-  let target = {};
-  for (var name in all) {
-    __defProp3(target, name, {
-      get: all[name],
-      enumerable: true
-    });
-  }
-  if (symbols) {
-    __defProp3(target, Symbol.toStringTag, { value: "Module" });
+function serviceNames(profile) {
+  if (profile === "production") {
+    return { launchd: SERVICE_LABEL, systemd: SYSTEMD_UNIT, windows: WINDOWS_TASK };
   }
-  return target;
-};
-var __copyProps3 = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var keys = __getOwnPropNames3(from), i = 0, n = keys.length, key; i < n; i++) {
-      key = keys[i];
-      if (!__hasOwnProp3.call(to, key) && key !== except) {
-        __defProp3(to, key, {
-          get: ((k) => from[k]).bind(null, key),
-          enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable
-        });
-      }
-    }
+  const suffix = profile === "custom" ? "prod" : profile;
+  const title = `${suffix[0]?.toUpperCase()}${suffix.slice(1)}`;
+  return {
+    launchd: `${SERVICE_LABEL}.${suffix}`,
+    systemd: `alan-agent-${suffix}.service`,
+    windows: `${WINDOWS_TASK} ${title}`
+  };
+}
+function buildDaemonServicePlan(input2) {
+  const daemonArgs = [input2.nodeExecutable, input2.cliEntry, "daemon", "--profile", input2.profile];
+  const names = serviceNames(input2.profile);
+  if (input2.platform === "darwin") {
+    const userId = input2.userId ?? process.getuid?.();
+    if (userId === void 0) throw new Error("Cannot determine the current macOS user ID");
+    const domain2 = `gui/${userId}`;
+    const serviceTarget = `${domain2}/${names.launchd}`;
+    const manifestPath = (0, import_node_path27.join)(input2.homeDir, "Library", "LaunchAgents", `${names.launchd}.plist`);
+    const logDir = (0, import_node_path27.join)(resolveAgentConfigDirectory(input2.profile, input2.homeDir), "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");
+    const environmentBlock = environmentEntries ? `  <key>EnvironmentVariables</key>
+  <dict>
+${environmentEntries}
+  </dict>
+` : "";
+    const manifest = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${names.launchd}</string>
+  <key>ProgramArguments</key>
+  <array>
+${programArguments}
+  </array>
+${environmentBlock}  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>5</integer>
+  <key>StandardOutPath</key>
+  <string>${xml((0, import_node_path27.join)(logDir, "daemon.log"))}</string>
+  <key>StandardErrorPath</key>
+  <string>${xml((0, import_node_path27.join)(logDir, "daemon-error.log"))}</string>
+</dict>
+</plist>
+`;
+    return {
+      platform: "darwin",
+      manifestPath,
+      manifest,
+      logDirectory: logDir,
+      loadDefinitionCommands: [
+        {
+          command: "launchctl",
+          args: ["bootstrap", domain2, manifestPath],
+          tolerateFailure: true
+        }
+      ],
+      reloadDefinitionCommands: [
+        {
+          command: "launchctl",
+          args: ["bootout", domain2, manifestPath],
+          tolerateFailure: true
+        },
+        {
+          command: "launchctl",
+          args: ["bootstrap", domain2, manifestPath],
+          tolerateFailure: false
+        }
+      ],
+      enableCommands: [
+        {
+          command: "launchctl",
+          args: ["enable", serviceTarget],
+          tolerateFailure: true
+        }
+      ],
+      startCommands: [
+        {
+          command: "launchctl",
+          args: ["kickstart", serviceTarget],
+          tolerateFailure: false
+        }
+      ],
+      stopCommands: [
+        {
+          command: "launchctl",
+          args: ["kill", "SIGTERM", serviceTarget],
+          tolerateFailure: true
+        }
+      ],
+      replaceCommands: [
+        {
+          command: "launchctl",
+          args: ["bootout", domain2, manifestPath],
+          tolerateFailure: true
+        },
+        {
+          command: "launchctl",
+          args: ["bootstrap", domain2, manifestPath],
+          tolerateFailure: false
+        },
+        {
+          command: "launchctl",
+          args: ["kickstart", "-k", serviceTarget],
+          tolerateFailure: false
+        }
+      ],
+      uninstallCommands: [
+        {
+          command: "launchctl",
+          args: ["bootout", domain2, manifestPath],
+          tolerateFailure: true
+        }
+      ],
+      statusCommand: {
+        command: "launchctl",
+        args: ["print", serviceTarget],
+        tolerateFailure: true
+      },
+      isActiveCommand: {
+        command: "launchctl",
+        args: ["print", serviceTarget],
+        tolerateFailure: true
+      },
+      lingerStatusCommand: null
+    };
   }
-  return to;
-};
-var __toESM3 = (mod, isNodeMode, target) => (target = mod != null ? __create3(__getProtoOf3(mod)) : {}, __copyProps3(isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", {
-  value: mod,
-  enumerable: true
-}) : target, mod));
+  if (input2.platform === "linux") {
+    const manifestPath = (0, import_node_path27.join)(input2.homeDir, ".config", "systemd", "user", names.systemd);
+    const environmentLines = Object.entries(input2.environment ?? {}).map(([key, value2]) => `Environment=${systemdArg(`${key}=${value2}`)}`).join("\n");
+    const manifest = `[Unit]
+Description=Alan local agent daemon
+After=network-online.target
+Wants=network-online.target
+StartLimitIntervalSec=300
+StartLimitBurst=3
 
-// ../../node_modules/@modelcontextprotocol/server/dist/dialects-DoSzNhcb.mjs
-var DRAFT_2020_12_URIS2 = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2020-12/schema", "http://json-schema.org/draft/2020-12/schema"]);
-var DRAFT_2019_09_URIS2 = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2019-09/schema", "http://json-schema.org/draft/2019-09/schema"]);
-var DRAFT_07_URIS2 = /* @__PURE__ */ new Set(["https://json-schema.org/draft-07/schema", "http://json-schema.org/draft-07/schema"]);
-var DRAFT_06_URIS2 = /* @__PURE__ */ new Set(["https://json-schema.org/draft-06/schema", "http://json-schema.org/draft-06/schema"]);
-function declares2019Dialect2($schema) {
-  return typeof $schema === "string" && DRAFT_2019_09_URIS2.has($schema.replace(/#$/, ""));
-}
-function declaredDialect2(schema, remedy) {
-  if (!("$schema" in schema) || typeof schema.$schema !== "string") return "2020-12";
-  const declared = schema.$schema.replace(/#$/, "");
-  if (DRAFT_2020_12_URIS2.has(declared)) return "2020-12";
-  if (DRAFT_2019_09_URIS2.has(declared)) return "2019-09";
-  if (DRAFT_07_URIS2.has(declared) || DRAFT_06_URIS2.has(declared)) return "draft-7";
-  throw new Error(`JSON Schema declares an unsupported dialect ("$schema": "${schema.$schema.slice(0, 200)}"). The default validator supports JSON Schema 2020-12, 2019-09, draft-07, and draft-06; ${remedy}`);
-}
+[Service]
+Type=simple
+${environmentLines ? `${environmentLines}
+` : ""}ExecStart=${daemonArgs.map(systemdArg).join(" ")}
+Restart=on-failure
+RestartSec=5
 
-// ../../node_modules/@modelcontextprotocol/server/dist/src-CX2iR2pK.mjs
-var BRANDS2 = /* @__PURE__ */ Symbol.for("mcp.sdk.errorBrands");
-function stampErrorBrands2(instance, ctor) {
-  const brands = /* @__PURE__ */ new Set();
-  let current = ctor;
-  while (typeof current === "function") {
-    const brand = current.mcpBrand;
-    if (Object.prototype.hasOwnProperty.call(current, "mcpBrand") && typeof brand === "string") brands.add(brand);
-    current = Object.getPrototypeOf(current);
-  }
-  if (brands.size === 0) return;
-  Object.defineProperty(instance, BRANDS2, {
-    value: brands,
-    enumerable: false,
-    configurable: true
-  });
-}
-function brandedHasInstance2(cls, value2) {
-  try {
-    if (typeof value2 === "object" && value2 !== null && Object.prototype.hasOwnProperty.call(cls, "mcpBrand") && typeof cls.mcpBrand === "string" && Object.prototype.hasOwnProperty.call(value2, BRANDS2)) {
-      const carried = value2[BRANDS2];
-      if (carried && typeof carried.has === "function" && carried.has(cls.mcpBrand)) return true;
-    }
-  } catch {
-  }
-  return Function.prototype[Symbol.hasInstance].call(cls, value2);
-}
-var OAuthError3 = class OAuthError4 extends Error {
-  static {
-    Object.defineProperty(this, "mcpBrand", { value: "mcp.OAuthError" });
-  }
-  static [Symbol.hasInstance](value2) {
-    return brandedHasInstance2(this, value2);
-  }
-  /**
-  * Brand-based type guard: equivalent to `value instanceof this`, as an
-  * explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
-  * the caller's own brand via `this`, so every branded subclass gets a
-  * correctly-scoped guard by inheritance. Must be invoked on the class —
-  * in callback position write `v => SdkError.isInstance(v)`, not
-  * `.filter(SdkError.isInstance)` (detached calls throw rather than
-  * silently matching nothing).
-  */
-  static isInstance(value2) {
-    if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
-    return brandedHasInstance2(this, value2);
+[Install]
+WantedBy=default.target
+`;
+    return {
+      platform: "linux",
+      manifestPath,
+      manifest,
+      logDirectory: null,
+      loadDefinitionCommands: [
+        {
+          command: "systemctl",
+          args: ["--user", "daemon-reload"],
+          tolerateFailure: false
+        }
+      ],
+      reloadDefinitionCommands: [
+        {
+          command: "systemctl",
+          args: ["--user", "daemon-reload"],
+          tolerateFailure: false
+        }
+      ],
+      enableCommands: [
+        {
+          command: "systemctl",
+          args: ["--user", "enable", names.systemd],
+          tolerateFailure: false
+        }
+      ],
+      startCommands: [
+        {
+          command: "systemctl",
+          args: ["--user", "start", names.systemd],
+          tolerateFailure: false
+        }
+      ],
+      stopCommands: [
+        {
+          command: "systemctl",
+          args: ["--user", "stop", names.systemd],
+          tolerateFailure: true
+        }
+      ],
+      replaceCommands: [
+        {
+          command: "systemctl",
+          args: ["--user", "daemon-reload"],
+          tolerateFailure: false
+        },
+        {
+          command: "systemctl",
+          args: ["--user", "restart", names.systemd],
+          tolerateFailure: false
+        }
+      ],
+      uninstallCommands: [
+        {
+          command: "systemctl",
+          args: ["--user", "disable", "--now", names.systemd],
+          tolerateFailure: true
+        },
+        {
+          command: "systemctl",
+          args: ["--user", "daemon-reload"],
+          tolerateFailure: false
+        }
+      ],
+      statusCommand: {
+        command: "systemctl",
+        args: ["--user", "status", names.systemd, "--no-pager"],
+        tolerateFailure: true
+      },
+      isActiveCommand: {
+        command: "systemctl",
+        args: ["--user", "is-active", names.systemd],
+        tolerateFailure: true
+      },
+      lingerStatusCommand: {
+        command: "loginctl",
+        args: ["show-user", "$(id -un)", "-p", "Linger"],
+        tolerateFailure: true
+      }
+    };
   }
-  constructor(code, message, errorUri) {
-    super(message);
-    this.code = code;
-    this.errorUri = errorUri;
-    this.name = "OAuthError";
-    stampErrorBrands2(this, new.target);
+  const environmentPrefix = Object.entries(input2.environment ?? {}).map(([key, value2]) => `$env:${key} = ${powershellLiteral(value2)}`).join("; ");
+  const directArgument = [input2.cliEntry, "daemon", "--profile", input2.profile].map((part) => part.includes(" ") ? `"${part}"` : part).join(" ");
+  const executable = powershellLiteral(environmentPrefix ? "powershell.exe" : input2.nodeExecutable);
+  const argument = powershellLiteral(
+    environmentPrefix ? `-NoProfile -NonInteractive -WindowStyle Hidden -Command "${environmentPrefix}; & ${powershellLiteral(input2.nodeExecutable)} ${powershellLiteral(input2.cliEntry)} daemon --profile ${input2.profile}"` : directArgument
+  );
+  const registerScript = [
+    "$currentUser = [System.Security.Principal.WindowsIdentity]::GetCurrent().Name",
+    `$action = New-ScheduledTaskAction -Execute ${executable} -Argument ${argument}`,
+    "$trigger = New-ScheduledTaskTrigger -AtLogOn -User $currentUser",
+    "$principal = New-ScheduledTaskPrincipal -UserId $currentUser -LogonType Interactive -RunLevel Limited",
+    "$settings = New-ScheduledTaskSettingsSet -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1) -ExecutionTimeLimit ([TimeSpan]::Zero)",
+    `Register-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Force | Out-Null`
+  ].join("; ");
+  return {
+    platform: "win32",
+    manifestPath: null,
+    manifest: null,
+    logDirectory: null,
+    loadDefinitionCommands: [
+      {
+        command: "powershell.exe",
+        args: ["-NoProfile", "-NonInteractive", "-Command", registerScript],
+        tolerateFailure: false
+      }
+    ],
+    reloadDefinitionCommands: [
+      {
+        command: "powershell.exe",
+        args: ["-NoProfile", "-NonInteractive", "-Command", registerScript],
+        tolerateFailure: false
+      }
+    ],
+    enableCommands: [],
+    startCommands: [
+      {
+        command: "powershell.exe",
+        args: [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `Start-ScheduledTask -TaskName ${powershellLiteral(names.windows)}`
+        ],
+        tolerateFailure: false
+      }
+    ],
+    stopCommands: [
+      {
+        command: "powershell.exe",
+        args: [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `Stop-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -ErrorAction SilentlyContinue`
+        ],
+        tolerateFailure: true
+      }
+    ],
+    replaceCommands: [
+      {
+        command: "powershell.exe",
+        args: [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `${registerScript}; Start-ScheduledTask -TaskName ${powershellLiteral(names.windows)}`
+        ],
+        tolerateFailure: false
+      }
+    ],
+    uninstallCommands: [
+      {
+        command: "powershell.exe",
+        args: [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `Unregister-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -Confirm:$false -ErrorAction SilentlyContinue`
+        ],
+        tolerateFailure: true
+      }
+    ],
+    statusCommand: {
+      command: "powershell.exe",
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Get-ScheduledTask -TaskName ${powershellLiteral(names.windows)} | Format-List TaskName,State`
+      ],
+      tolerateFailure: true
+    },
+    isActiveCommand: {
+      command: "powershell.exe",
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `(Get-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -ErrorAction SilentlyContinue).State`
+      ],
+      tolerateFailure: true
+    },
+    lingerStatusCommand: null
+  };
+}
+function resolveCurrentPlatform() {
+  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}`);
   }
-  /**
-  * Converts the error to a standard OAuth error response object.
-  */
-  toResponseObject() {
-    const response = {
-      error: this.code,
-      error_description: this.message
-    };
-    if (this.errorUri) response.error_uri = this.errorUri;
-    return response;
+  return currentPlatform;
+}
+function currentServicePlan(args, runtime) {
+  const currentPlatform = resolveCurrentPlatform();
+  const profile = resolveEndpointProfileFromArgs(args);
+  const cliEntry = runtime?.cliEntry ?? process.argv[1];
+  if (!cliEntry) throw new Error("Cannot determine the alan-agent executable path");
+  return buildDaemonServicePlan({
+    platform: currentPlatform,
+    homeDir: (0, import_node_os16.homedir)(),
+    nodeExecutable: runtime?.executable ?? process.execPath,
+    cliEntry: (0, import_node_path27.resolve)(cliEntry),
+    profile,
+    environment: runtime?.environment
+  });
+}
+function writeManifestAtomic(path2, contents) {
+  (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 });
+    (0, import_node_fs25.chmodSync)(pendingPath, 384);
+    (0, import_node_fs25.renameSync)(pendingPath, path2);
+  } finally {
+    (0, import_node_fs25.rmSync)(pendingPath, { force: true });
   }
-  /**
-  * Creates an {@linkcode OAuthError} from an OAuth error response.
-  */
-  static fromResponse(response) {
-    return new OAuthError4(response.error, response.error_description ?? response.error, response.error_uri);
+}
+function defaultReadManifest(path2) {
+  if (!(0, import_node_fs25.existsSync)(path2)) return null;
+  return (0, import_node_fs25.readFileSync)(path2, "utf8");
+}
+function runServiceCommand(command) {
+  const result = (0, import_node_child_process9.spawnSync)(command.command, command.args, { encoding: "utf8", shell: false });
+  const status = result.status ?? 1;
+  const output2 = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  if (status !== 0 && !command.tolerateFailure) {
+    throw new Error(
+      `Service command failed (${command.command} ${command.args.join(" ")}): ${output2 || `exit ${status}`}`
+    );
   }
-};
-var SdkErrorCode2 = /* @__PURE__ */ (function(SdkErrorCode$1) {
-  SdkErrorCode$1["NotConnected"] = "NOT_CONNECTED";
-  SdkErrorCode$1["AlreadyConnected"] = "ALREADY_CONNECTED";
-  SdkErrorCode$1["NotInitialized"] = "NOT_INITIALIZED";
-  SdkErrorCode$1["CapabilityNotSupported"] = "CAPABILITY_NOT_SUPPORTED";
-  SdkErrorCode$1["RequestTimeout"] = "REQUEST_TIMEOUT";
-  SdkErrorCode$1["ConnectionClosed"] = "CONNECTION_CLOSED";
-  SdkErrorCode$1["SendFailed"] = "SEND_FAILED";
-  SdkErrorCode$1["InvalidResult"] = "INVALID_RESULT";
-  SdkErrorCode$1["UnsupportedResultType"] = "UNSUPPORTED_RESULT_TYPE";
-  SdkErrorCode$1["InputRequiredRoundsExceeded"] = "INPUT_REQUIRED_ROUNDS_EXCEEDED";
-  SdkErrorCode$1["ListPaginationExceeded"] = "LIST_PAGINATION_EXCEEDED";
-  SdkErrorCode$1["MethodNotSupportedByProtocolVersion"] = "METHOD_NOT_SUPPORTED_BY_PROTOCOL_VERSION";
-  SdkErrorCode$1["EraNegotiationFailed"] = "ERA_NEGOTIATION_FAILED";
-  SdkErrorCode$1["ClientHttpNotImplemented"] = "CLIENT_HTTP_NOT_IMPLEMENTED";
-  SdkErrorCode$1["ClientHttpAuthentication"] = "CLIENT_HTTP_AUTHENTICATION";
-  SdkErrorCode$1["ClientHttpForbidden"] = "CLIENT_HTTP_FORBIDDEN";
-  SdkErrorCode$1["ClientHttpUnexpectedContent"] = "CLIENT_HTTP_UNEXPECTED_CONTENT";
-  SdkErrorCode$1["ClientHttpFailedToOpenStream"] = "CLIENT_HTTP_FAILED_TO_OPEN_STREAM";
-  SdkErrorCode$1["ClientHttpFailedToTerminateSession"] = "CLIENT_HTTP_FAILED_TO_TERMINATE_SESSION";
-  return SdkErrorCode$1;
-})({});
-var SdkError2 = class extends Error {
-  static {
-    Object.defineProperty(this, "mcpBrand", { value: "mcp.SdkError" });
+  return { status, output: output2 };
+}
+function defaultSleep(ms) {
+  return new Promise((resolveSleep) => {
+    setTimeout(resolveSleep, ms);
+  });
+}
+function parseServiceHostState(servicePlatform, result) {
+  const output2 = result.output;
+  if (servicePlatform === "linux") {
+    const trimmed = output2.trim().toLowerCase();
+    if (trimmed === "inactive" || trimmed === "failed" || trimmed === "dead" || /\binactive\b/i.test(output2) || /\bfailed\b/i.test(output2)) {
+      return "stopped";
+    }
   }
-  static [Symbol.hasInstance](value2) {
-    return brandedHasInstance2(this, value2);
+  if (result.status !== 0) return "unknown";
+  if (servicePlatform === "darwin") {
+    if (/\bstate\s*=\s*running\b/i.test(output2)) return "running";
+    if (/\bstate\s*=\s*(not running|waiting|stopped)\b/i.test(output2)) return "stopped";
+    if (/\bpid\s*=\s*[1-9]\d*\b/i.test(output2)) return "running";
+    if (/could not find service/i.test(output2)) return "stopped";
+    return "unknown";
   }
-  /**
-  * Brand-based type guard: equivalent to `value instanceof this`, as an
-  * explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
-  * the caller's own brand via `this`, so every branded subclass gets a
-  * correctly-scoped guard by inheritance. Must be invoked on the class —
-  * in callback position write `v => SdkError.isInstance(v)`, not
-  * `.filter(SdkError.isInstance)` (detached calls throw rather than
-  * silently matching nothing).
-  */
-  static isInstance(value2) {
-    if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
-    return brandedHasInstance2(this, value2);
+  if (servicePlatform === "linux") {
+    const trimmed = output2.trim().toLowerCase();
+    if (trimmed === "active" || /\bactive\s*\(running\)/i.test(output2)) return "running";
+    if (trimmed === "activating" || trimmed === "reloading") return "starting";
+    return "unknown";
   }
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-    this.name = "SdkError";
-    stampErrorBrands2(this, new.target);
+  const stateMatch = output2.match(/\b(?:State|state)\s*[:=]\s*(\w+)/);
+  const state = (stateMatch?.[1] ?? output2.trim()).toLowerCase();
+  if (state === "running") return "running";
+  if (state === "ready" || state === "disabled" || state === "queued") return "stopped";
+  return "unknown";
+}
+function resolveEnsureDefinitionOutcome(input2) {
+  if (!input2.definitionChanged) {
+    return { changed: false, updatePending: false };
   }
-};
-var SdkHttpError2 = class extends SdkError2 {
-  static {
-    Object.defineProperty(this, "mcpBrand", { value: "mcp.SdkHttpError" });
+  if (input2.hostState === "running" || input2.hostState === "starting") {
+    return { changed: true, updatePending: true };
   }
-  constructor(code, message, data) {
-    super(code, message, data);
-    this.name = "SdkHttpError";
+  return { changed: true, updatePending: false };
+}
+function shouldStartOnInstall(hostState) {
+  return hostState === "stopped";
+}
+function resolveUsername(options) {
+  if (options?.username) return options.username;
+  try {
+    return (0, import_node_os16.userInfo)().username;
+  } catch {
+    return process.env.USER || process.env.USERNAME || "unknown";
   }
-  get status() {
-    return this.data.status;
+}
+function buildLingerStatusCommand(username) {
+  return {
+    command: "loginctl",
+    args: ["show-user", username, "-p", "Linger"],
+    tolerateFailure: true
+  };
+}
+function assertSystemdUserLingerEnabled(options = {}) {
+  const username = resolveUsername(options);
+  const run = options.runCommand ?? runServiceCommand;
+  const result = run(buildLingerStatusCommand(username));
+  if (result.status !== 0) {
+    throw new Error(
+      `Cannot verify systemd user linger for ${username} (loginctl failed). For durable headless VM boot run: sudo loginctl enable-linger ${username}`
+    );
   }
-  get statusText() {
-    return this.data.statusText;
+  if (!/Linger=yes/i.test(result.output)) {
+    throw new Error(
+      `systemd user linger is disabled for ${username}. For durable headless VM boot run: sudo loginctl enable-linger ${username}`
+    );
   }
-};
-function isPlainObject$7(value2) {
-  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
 }
-function isImpliedCapabilityMember(capability, member, declaredValue) {
-  return capability === "elicitation" && member === "form" && declaredValue["form"] === void 0 && declaredValue["url"] === void 0;
+function createHostContext(options = {}) {
+  const args = options.args ?? [];
+  const plan = currentServicePlan(args, options.runtime);
+  const run = options.runCommand ?? runServiceCommand;
+  const sleep4 = options.sleep ?? defaultSleep;
+  const nowMs = options.nowMs ?? Date.now;
+  const readManifest = options.readManifest ?? defaultReadManifest;
+  const writeManifest = options.writeManifest ?? writeManifestAtomic;
+  const removeManifest = options.removeManifest ?? ((path2) => (0, import_node_fs25.rmSync)(path2, { force: true }));
+  const ensureLogDir = options.ensureLogDir ?? (() => {
+    if (plan.logDirectory) (0, import_node_fs25.mkdirSync)(plan.logDirectory, { recursive: true, mode: 448 });
+  });
+  return {
+    args,
+    plan,
+    run,
+    sleep: sleep4,
+    nowMs,
+    readManifest,
+    writeManifest,
+    removeManifest,
+    ensureLogDir,
+    profile: resolveEndpointProfileFromArgs(args)
+  };
 }
-function requiredClientCapabilitiesForInputRequest(entry) {
-  switch (entry.method) {
-    case "elicitation/create":
-      if (entry.params?.["mode"] === "url") return { elicitation: { url: {} } };
-      return { elicitation: { form: {} } };
-    case "sampling/createMessage": {
-      const params = entry.params;
-      if (params !== void 0 && (params["tools"] !== void 0 || params["toolChoice"] !== void 0)) return { sampling: { tools: {} } };
-      return { sampling: {} };
+function inspectDaemonService(options = {}) {
+  const { plan, run, nowMs } = createHostContext(options);
+  const result = run(plan.isActiveCommand);
+  const state = parseServiceHostState(plan.platform, result);
+  return {
+    state,
+    platform: plan.platform,
+    detail: result.output || void 0,
+    observedAtMs: nowMs()
+  };
+}
+function ensureDaemonServiceDefinition(options = {}) {
+  const ctx = createHostContext(options);
+  const { plan, run, readManifest, writeManifest, ensureLogDir } = ctx;
+  let definitionChanged = false;
+  if (plan.manifestPath && plan.manifest) {
+    ensureLogDir();
+    const existing = readManifest(plan.manifestPath);
+    definitionChanged = existing !== plan.manifest;
+    if (definitionChanged) {
+      writeManifest(plan.manifestPath, plan.manifest);
     }
-    case "roots/list":
-      return { roots: {} };
-    default:
-      return;
+  } else if (plan.platform === "win32") {
+    definitionChanged = true;
+  }
+  const inspection = inspectDaemonService(options);
+  const outcome = resolveEnsureDefinitionOutcome({
+    definitionChanged,
+    hostState: inspection.state
+  });
+  if (outcome.updatePending) {
+    return outcome;
+  }
+  if (inspection.state === "running" || inspection.state === "starting") {
+    return outcome;
   }
+  const definitionCommands = inspection.state === "stopped" ? plan.reloadDefinitionCommands : plan.loadDefinitionCommands;
+  for (const command of definitionCommands) run(command);
+  return outcome;
 }
-function missingClientCapabilities(required2, declared) {
-  const missing = {};
-  for (const [capability, requirement] of Object.entries(required2)) {
-    if (requirement === void 0) continue;
-    const declaredValue = declared === void 0 ? void 0 : declared[capability];
-    if (declaredValue === void 0) {
-      missing[capability] = requirement;
-      continue;
-    }
-    if (isPlainObject$7(requirement) && isPlainObject$7(declaredValue)) {
-      const missingMembers = {};
-      for (const [member, memberRequirement] of Object.entries(requirement)) if (memberRequirement !== void 0 && declaredValue[member] === void 0 && !isImpliedCapabilityMember(capability, member, declaredValue)) missingMembers[member] = memberRequirement;
-      if (Object.keys(missingMembers).length > 0) missing[capability] = missingMembers;
+function enableDaemonService(options = {}) {
+  const { plan, run } = createHostContext(options);
+  for (const command of plan.enableCommands) run(command);
+}
+function startDaemonService(options = {}) {
+  const { plan, run } = createHostContext(options);
+  for (const command of plan.startCommands) run(command);
+}
+function uninstallDaemonService(args = [], options = {}) {
+  const ctx = createHostContext({ ...options, args: options.args ?? args });
+  for (const command of ctx.plan.uninstallCommands) ctx.run(command);
+  if (ctx.plan.manifestPath) ctx.removeManifest(ctx.plan.manifestPath);
+  console.info("[alan-agent] Per-user daemon service removed");
+}
+function installDaemonService(args = [], runtime, options = {}) {
+  const profile = resolveEndpointProfileFromArgs(args);
+  const configPath = resolveAgentConfigPath({ profile });
+  if (!configExistsAtPath(configPath)) {
+    throw new Error(`No ${profile} runtime is configured. Run alan-agent setup or login first.`);
+  }
+  const headless = options.headless ?? args.includes("--headless");
+  const merged = { ...options, args, runtime, headless };
+  const ctx = createHostContext(merged);
+  if (headless) {
+    if (ctx.plan.platform !== "linux") {
+      throw new Error("--headless is only supported on Linux systemd user services");
     }
+    assertSystemdUserLingerEnabled(merged);
   }
-  return Object.keys(missing).length > 0 ? missing : void 0;
-}
-var FIRST_MODERN_PROTOCOL_VERSION2 = "2026-07-28";
-function isModernProtocolVersion2(version2) {
-  return version2 >= FIRST_MODERN_PROTOCOL_VERSION2;
+  const ensured = ensureDaemonServiceDefinition(merged);
+  enableDaemonService(merged);
+  const inspection = inspectDaemonService(merged);
+  if (ensured.updatePending) {
+    console.info("[alan-agent] Daemon service definition update pending; leaving running service", {
+      profile,
+      state: inspection.state
+    });
+    return;
+  }
+  if (!shouldStartOnInstall(inspection.state)) {
+    console.info("[alan-agent] Per-user daemon service already present", {
+      profile,
+      state: inspection.state
+    });
+    return;
+  }
+  startDaemonService(merged);
+  console.info("[alan-agent] Per-user daemon service installed", { profile });
 }
-function legacyProtocolVersions2(versions) {
-  return versions.filter((version2) => !isModernProtocolVersion2(version2));
+function printDaemonServiceStatus(args = []) {
+  const plan = currentServicePlan(args);
+  const result = runServiceCommand({ ...plan.statusCommand, tolerateFailure: true });
+  if (result.status !== 0) {
+    process.stdout.write(`unknown
+${result.output}
+`);
+    return;
+  }
+  process.stdout.write(`${result.output}
+`);
 }
-function modernProtocolVersions2(versions) {
-  return versions.filter((version2) => isModernProtocolVersion2(version2));
+
+// src/install-command.ts
+async function runInstallCommand(commandArgs) {
+  bindConfigPath(commandArgs);
+  const configured = readConfig();
+  const configurationMode = resolveInstallConfigurationMode(commandArgs, configured);
+  if (configurationMode === "setup") await setupDaemon(commandArgs);
+  if (configurationMode === "login") await loginWithDeviceCode(commandArgs);
+  installDaemonService(commandArgs);
+  runMcpIntegrationCommand(["reconcile", ...commandArgs]);
 }
-function appendTextFallbackForNonObject2(result) {
-  const sc = result.structuredContent;
-  if (sc === void 0) return result;
-  if (!(typeof sc !== "object" || sc === null || Array.isArray(sc))) return result;
-  if (result.content?.some((c) => c.type === "text") ?? false) return result;
-  return {
-    ...result,
-    content: [...result.content ?? [], {
-      type: "text",
-      text: JSON.stringify(sc)
-    }]
-  };
+
+// src/lifecycle-logger.ts
+var AgentLifecycleLogger = class _AgentLifecycleLogger {
+  context;
+  constructor(context = {}) {
+    this.context = normalizeContext(context);
+  }
+  setContext(context) {
+    this.context = normalizeContext({ ...this.context, ...context });
+  }
+  child(context) {
+    return new _AgentLifecycleLogger({ ...this.context, ...context });
+  }
+  debug(event, fields = {}) {
+    this.log("debug", event, fields);
+  }
+  info(event, fields = {}) {
+    this.log("info", event, fields);
+  }
+  warn(event, fields = {}) {
+    this.log("warn", event, fields);
+  }
+  error(event, fields = {}) {
+    this.log("error", event, fields);
+  }
+  log(level, event, fields) {
+    const record2 = omitUndefined({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      component: "agent-manager",
+      event,
+      ...this.context,
+      ...normalizeFields(fields)
+    });
+    console[level](JSON.stringify(record2));
+  }
+};
+function lifecycleContextFromEnv(env) {
+  return normalizeContext({
+    taskId: env.ALAN_TASK_ID,
+    conversationId: env.ALAN_SESSION_ID,
+    runId: env.ALAN_RUN_ID,
+    sandboxId: env.ALAN_SANDBOX_ID,
+    provider: env.ALAN_SANDBOX_PROVIDER,
+    backendKind: env.ALAN_BACKEND_KIND,
+    agentVersion: AGENT_VERSION
+  });
 }
-var TOOL_RESULT_FOREIGN_FAMILY_KEYS2 = [
-  "task",
-  "inputRequests",
-  "requestState"
-];
-function normalizeContentlessToolResult2(value2) {
-  if (value2 === null || typeof value2 !== "object" || Array.isArray(value2) || value2.content !== void 0 || TOOL_RESULT_FOREIGN_FAMILY_KEYS2.some((key) => key in value2)) return value2;
-  return {
-    ...value2,
-    content: []
-  };
+function normalizeContext(context) {
+  return omitUndefined({
+    ...context,
+    agentVersion: context.agentVersion ?? AGENT_VERSION
+  });
+}
+function normalizeFields(fields) {
+  const normalized = {};
+  for (const [key, value2] of Object.entries(fields)) {
+    if (value2 instanceof Error) {
+      normalized[key] = {
+        name: value2.name,
+        message: value2.message,
+        stack: value2.stack
+      };
+    } else {
+      normalized[key] = value2;
+    }
+  }
+  return normalized;
+}
+function omitUndefined(record2) {
+  return Object.fromEntries(Object.entries(record2).filter(([, value2]) => value2 !== void 0));
+}
+
+// ../../node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
+var __create3 = Object.create;
+var __defProp3 = Object.defineProperty;
+var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames3 = Object.getOwnPropertyNames;
+var __getProtoOf3 = Object.getPrototypeOf;
+var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+var __commonJSMin2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll2 = (all, symbols) => {
+  let target = {};
+  for (var name in all) {
+    __defProp3(target, name, {
+      get: all[name],
+      enumerable: true
+    });
+  }
+  if (symbols) {
+    __defProp3(target, Symbol.toStringTag, { value: "Module" });
+  }
+  return target;
+};
+var __copyProps3 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var keys = __getOwnPropNames3(from), i = 0, n = keys.length, key; i < n; i++) {
+      key = keys[i];
+      if (!__hasOwnProp3.call(to, key) && key !== except) {
+        __defProp3(to, key, {
+          get: ((k) => from[k]).bind(null, key),
+          enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable
+        });
+      }
+    }
+  }
+  return to;
+};
+var __toESM3 = (mod, isNodeMode, target) => (target = mod != null ? __create3(__getProtoOf3(mod)) : {}, __copyProps3(isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+
+// ../../node_modules/@modelcontextprotocol/server/dist/dialects-DoSzNhcb.mjs
+var DRAFT_2020_12_URIS2 = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2020-12/schema", "http://json-schema.org/draft/2020-12/schema"]);
+var DRAFT_2019_09_URIS2 = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2019-09/schema", "http://json-schema.org/draft/2019-09/schema"]);
+var DRAFT_07_URIS2 = /* @__PURE__ */ new Set(["https://json-schema.org/draft-07/schema", "http://json-schema.org/draft-07/schema"]);
+var DRAFT_06_URIS2 = /* @__PURE__ */ new Set(["https://json-schema.org/draft-06/schema", "http://json-schema.org/draft-06/schema"]);
+function declares2019Dialect2($schema) {
+  return typeof $schema === "string" && DRAFT_2019_09_URIS2.has($schema.replace(/#$/, ""));
+}
+function declaredDialect2(schema, remedy) {
+  if (!("$schema" in schema) || typeof schema.$schema !== "string") return "2020-12";
+  const declared = schema.$schema.replace(/#$/, "");
+  if (DRAFT_2020_12_URIS2.has(declared)) return "2020-12";
+  if (DRAFT_2019_09_URIS2.has(declared)) return "2019-09";
+  if (DRAFT_07_URIS2.has(declared) || DRAFT_06_URIS2.has(declared)) return "draft-7";
+  throw new Error(`JSON Schema declares an unsupported dialect ("$schema": "${schema.$schema.slice(0, 200)}"). The default validator supports JSON Schema 2020-12, 2019-09, draft-07, and draft-06; ${remedy}`);
+}
+
+// ../../node_modules/@modelcontextprotocol/server/dist/src-CX2iR2pK.mjs
+var BRANDS2 = /* @__PURE__ */ Symbol.for("mcp.sdk.errorBrands");
+function stampErrorBrands2(instance, ctor) {
+  const brands = /* @__PURE__ */ new Set();
+  let current = ctor;
+  while (typeof current === "function") {
+    const brand = current.mcpBrand;
+    if (Object.prototype.hasOwnProperty.call(current, "mcpBrand") && typeof brand === "string") brands.add(brand);
+    current = Object.getPrototypeOf(current);
+  }
+  if (brands.size === 0) return;
+  Object.defineProperty(instance, BRANDS2, {
+    value: brands,
+    enumerable: false,
+    configurable: true
+  });
+}
+function brandedHasInstance2(cls, value2) {
+  try {
+    if (typeof value2 === "object" && value2 !== null && Object.prototype.hasOwnProperty.call(cls, "mcpBrand") && typeof cls.mcpBrand === "string" && Object.prototype.hasOwnProperty.call(value2, BRANDS2)) {
+      const carried = value2[BRANDS2];
+      if (carried && typeof carried.has === "function" && carried.has(cls.mcpBrand)) return true;
+    }
+  } catch {
+  }
+  return Function.prototype[Symbol.hasInstance].call(cls, value2);
+}
+var OAuthError3 = class OAuthError4 extends Error {
+  static {
+    Object.defineProperty(this, "mcpBrand", { value: "mcp.OAuthError" });
+  }
+  static [Symbol.hasInstance](value2) {
+    return brandedHasInstance2(this, value2);
+  }
+  /**
+  * Brand-based type guard: equivalent to `value instanceof this`, as an
+  * explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
+  * the caller's own brand via `this`, so every branded subclass gets a
+  * correctly-scoped guard by inheritance. Must be invoked on the class —
+  * in callback position write `v => SdkError.isInstance(v)`, not
+  * `.filter(SdkError.isInstance)` (detached calls throw rather than
+  * silently matching nothing).
+  */
+  static isInstance(value2) {
+    if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
+    return brandedHasInstance2(this, value2);
+  }
+  constructor(code, message, errorUri) {
+    super(message);
+    this.code = code;
+    this.errorUri = errorUri;
+    this.name = "OAuthError";
+    stampErrorBrands2(this, new.target);
+  }
+  /**
+  * Converts the error to a standard OAuth error response object.
+  */
+  toResponseObject() {
+    const response = {
+      error: this.code,
+      error_description: this.message
+    };
+    if (this.errorUri) response.error_uri = this.errorUri;
+    return response;
+  }
+  /**
+  * Creates an {@linkcode OAuthError} from an OAuth error response.
+  */
+  static fromResponse(response) {
+    return new OAuthError4(response.error, response.error_description ?? response.error, response.error_uri);
+  }
+};
+var SdkErrorCode2 = /* @__PURE__ */ (function(SdkErrorCode$1) {
+  SdkErrorCode$1["NotConnected"] = "NOT_CONNECTED";
+  SdkErrorCode$1["AlreadyConnected"] = "ALREADY_CONNECTED";
+  SdkErrorCode$1["NotInitialized"] = "NOT_INITIALIZED";
+  SdkErrorCode$1["CapabilityNotSupported"] = "CAPABILITY_NOT_SUPPORTED";
+  SdkErrorCode$1["RequestTimeout"] = "REQUEST_TIMEOUT";
+  SdkErrorCode$1["ConnectionClosed"] = "CONNECTION_CLOSED";
+  SdkErrorCode$1["SendFailed"] = "SEND_FAILED";
+  SdkErrorCode$1["InvalidResult"] = "INVALID_RESULT";
+  SdkErrorCode$1["UnsupportedResultType"] = "UNSUPPORTED_RESULT_TYPE";
+  SdkErrorCode$1["InputRequiredRoundsExceeded"] = "INPUT_REQUIRED_ROUNDS_EXCEEDED";
+  SdkErrorCode$1["ListPaginationExceeded"] = "LIST_PAGINATION_EXCEEDED";
+  SdkErrorCode$1["MethodNotSupportedByProtocolVersion"] = "METHOD_NOT_SUPPORTED_BY_PROTOCOL_VERSION";
+  SdkErrorCode$1["EraNegotiationFailed"] = "ERA_NEGOTIATION_FAILED";
+  SdkErrorCode$1["ClientHttpNotImplemented"] = "CLIENT_HTTP_NOT_IMPLEMENTED";
+  SdkErrorCode$1["ClientHttpAuthentication"] = "CLIENT_HTTP_AUTHENTICATION";
+  SdkErrorCode$1["ClientHttpForbidden"] = "CLIENT_HTTP_FORBIDDEN";
+  SdkErrorCode$1["ClientHttpUnexpectedContent"] = "CLIENT_HTTP_UNEXPECTED_CONTENT";
+  SdkErrorCode$1["ClientHttpFailedToOpenStream"] = "CLIENT_HTTP_FAILED_TO_OPEN_STREAM";
+  SdkErrorCode$1["ClientHttpFailedToTerminateSession"] = "CLIENT_HTTP_FAILED_TO_TERMINATE_SESSION";
+  return SdkErrorCode$1;
+})({});
+var SdkError2 = class extends Error {
+  static {
+    Object.defineProperty(this, "mcpBrand", { value: "mcp.SdkError" });
+  }
+  static [Symbol.hasInstance](value2) {
+    return brandedHasInstance2(this, value2);
+  }
+  /**
+  * Brand-based type guard: equivalent to `value instanceof this`, as an
+  * explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
+  * the caller's own brand via `this`, so every branded subclass gets a
+  * correctly-scoped guard by inheritance. Must be invoked on the class —
+  * in callback position write `v => SdkError.isInstance(v)`, not
+  * `.filter(SdkError.isInstance)` (detached calls throw rather than
+  * silently matching nothing).
+  */
+  static isInstance(value2) {
+    if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
+    return brandedHasInstance2(this, value2);
+  }
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "SdkError";
+    stampErrorBrands2(this, new.target);
+  }
+};
+var SdkHttpError2 = class extends SdkError2 {
+  static {
+    Object.defineProperty(this, "mcpBrand", { value: "mcp.SdkHttpError" });
+  }
+  constructor(code, message, data) {
+    super(code, message, data);
+    this.name = "SdkHttpError";
+  }
+  get status() {
+    return this.data.status;
+  }
+  get statusText() {
+    return this.data.statusText;
+  }
+};
+function isPlainObject$7(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
+}
+function isImpliedCapabilityMember(capability, member, declaredValue) {
+  return capability === "elicitation" && member === "form" && declaredValue["form"] === void 0 && declaredValue["url"] === void 0;
+}
+function requiredClientCapabilitiesForInputRequest(entry) {
+  switch (entry.method) {
+    case "elicitation/create":
+      if (entry.params?.["mode"] === "url") return { elicitation: { url: {} } };
+      return { elicitation: { form: {} } };
+    case "sampling/createMessage": {
+      const params = entry.params;
+      if (params !== void 0 && (params["tools"] !== void 0 || params["toolChoice"] !== void 0)) return { sampling: { tools: {} } };
+      return { sampling: {} };
+    }
+    case "roots/list":
+      return { roots: {} };
+    default:
+      return;
+  }
+}
+function missingClientCapabilities(required2, declared) {
+  const missing = {};
+  for (const [capability, requirement] of Object.entries(required2)) {
+    if (requirement === void 0) continue;
+    const declaredValue = declared === void 0 ? void 0 : declared[capability];
+    if (declaredValue === void 0) {
+      missing[capability] = requirement;
+      continue;
+    }
+    if (isPlainObject$7(requirement) && isPlainObject$7(declaredValue)) {
+      const missingMembers = {};
+      for (const [member, memberRequirement] of Object.entries(requirement)) if (memberRequirement !== void 0 && declaredValue[member] === void 0 && !isImpliedCapabilityMember(capability, member, declaredValue)) missingMembers[member] = memberRequirement;
+      if (Object.keys(missingMembers).length > 0) missing[capability] = missingMembers;
+    }
+  }
+  return Object.keys(missing).length > 0 ? missing : void 0;
+}
+var FIRST_MODERN_PROTOCOL_VERSION2 = "2026-07-28";
+function isModernProtocolVersion2(version2) {
+  return version2 >= FIRST_MODERN_PROTOCOL_VERSION2;
+}
+function legacyProtocolVersions2(versions) {
+  return versions.filter((version2) => !isModernProtocolVersion2(version2));
+}
+function modernProtocolVersions2(versions) {
+  return versions.filter((version2) => isModernProtocolVersion2(version2));
+}
+function appendTextFallbackForNonObject2(result) {
+  const sc = result.structuredContent;
+  if (sc === void 0) return result;
+  if (!(typeof sc !== "object" || sc === null || Array.isArray(sc))) return result;
+  if (result.content?.some((c) => c.type === "text") ?? false) return result;
+  return {
+    ...result,
+    content: [...result.content ?? [], {
+      type: "text",
+      text: JSON.stringify(sc)
+    }]
+  };
+}
+var TOOL_RESULT_FOREIGN_FAMILY_KEYS2 = [
+  "task",
+  "inputRequests",
+  "requestState"
+];
+function normalizeContentlessToolResult2(value2) {
+  if (value2 === null || typeof value2 !== "object" || Array.isArray(value2) || value2.content !== void 0 || TOOL_RESULT_FOREIGN_FAMILY_KEYS2.some((key) => key in value2)) return value2;
+  return {
+    ...value2,
+    content: []
+  };
 }
 function build$12() {
   const JSONValueSchema$1 = lazy(() => union([
@@ -94584,27 +95428,27 @@ async function runMcpStdioProxy(env = process.env, local = new StdioServerTransp
 
 // src/native-hook-command.ts
 var import_node_crypto21 = require("crypto");
-var import_node_fs26 = require("fs");
-var import_node_os16 = require("os");
-var import_node_path28 = require("path");
+var import_node_fs27 = require("fs");
+var import_node_os17 = require("os");
+var import_node_path29 = require("path");
 
 // src/native-project-config.ts
-var import_node_fs25 = require("fs");
-var import_node_path27 = require("path");
+var import_node_fs26 = require("fs");
+var import_node_path28 = require("path");
 var MAX_ALAN_PROJECT_CONFIG_BYTES = 64 * 1024;
 var ORGANIZATION_SLUG_PATTERN = /^[a-z0-9-]+$/;
 var TEAM_IDENTIFIER_PATTERN = /^[A-Z0-9]{2,4}$/i;
 function readAlanProjectPin(cwd) {
   let fd;
   try {
-    fd = (0, import_node_fs25.openSync)(
-      (0, import_node_path27.join)(cwd, "alan.json"),
-      import_node_fs25.constants.O_RDONLY | import_node_fs25.constants.O_NONBLOCK | (import_node_fs25.constants.O_NOFOLLOW ?? 0)
+    fd = (0, import_node_fs26.openSync)(
+      (0, import_node_path28.join)(cwd, "alan.json"),
+      import_node_fs26.constants.O_RDONLY | import_node_fs26.constants.O_NONBLOCK | (import_node_fs26.constants.O_NOFOLLOW ?? 0)
     );
-    const stat2 = (0, import_node_fs25.fstatSync)(fd);
+    const stat2 = (0, import_node_fs26.fstatSync)(fd);
     if (!stat2.isFile() || stat2.size > MAX_ALAN_PROJECT_CONFIG_BYTES) return void 0;
     const buffer = Buffer.allocUnsafe(MAX_ALAN_PROJECT_CONFIG_BYTES + 1);
-    const bytesRead = (0, import_node_fs25.readSync)(fd, buffer, 0, buffer.byteLength, 0);
+    const bytesRead = (0, import_node_fs26.readSync)(fd, buffer, 0, buffer.byteLength, 0);
     if (bytesRead > MAX_ALAN_PROJECT_CONFIG_BYTES) return void 0;
     const parsed = JSON.parse(buffer.subarray(0, bytesRead).toString("utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
@@ -94620,7 +95464,7 @@ function readAlanProjectPin(cwd) {
   } finally {
     if (fd !== void 0) {
       try {
-        (0, import_node_fs25.closeSync)(fd);
+        (0, import_node_fs26.closeSync)(fd);
       } catch {
       }
     }
@@ -94859,19 +95703,19 @@ function nonNegativeIntegerField(payload, ...names) {
   return void 0;
 }
 function resolveCodexSessionIdFromTranscriptPath(transcriptPath) {
-  const fileName = (0, import_node_path28.basename)(transcriptPath);
+  const fileName = (0, import_node_path29.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_path28.join)((0, import_node_os16.homedir)(), ".kimi-code")) {
-  if ((0, import_node_path28.basename)(externalSessionId) !== externalSessionId) return void 0;
-  const sessionsDir = (0, import_node_path28.join)(kimiHomeDir, "sessions");
-  if (!(0, import_node_fs26.existsSync)(sessionsDir)) return void 0;
-  for (const workspace of (0, import_node_fs26.readdirSync)(sessionsDir, { withFileTypes: true })) {
+function resolveKimiTranscriptPath(externalSessionId, kimiHomeDir = process.env.KIMI_CODE_HOME?.trim() || (0, import_node_path29.join)((0, import_node_os17.homedir)(), ".kimi-code")) {
+  if ((0, import_node_path29.basename)(externalSessionId) !== externalSessionId) return void 0;
+  const sessionsDir = (0, import_node_path29.join)(kimiHomeDir, "sessions");
+  if (!(0, import_node_fs27.existsSync)(sessionsDir)) return void 0;
+  for (const workspace of (0, import_node_fs27.readdirSync)(sessionsDir, { withFileTypes: true })) {
     if (!workspace.isDirectory()) continue;
-    const transcriptPath = (0, import_node_path28.join)(
+    const transcriptPath = (0, import_node_path29.join)(
       sessionsDir,
       workspace.name,
       externalSessionId,
@@ -94879,7 +95723,7 @@ function resolveKimiTranscriptPath(externalSessionId, kimiHomeDir = process.env.
       "main",
       "wire.jsonl"
     );
-    if ((0, import_node_fs26.existsSync)(transcriptPath)) return transcriptPath;
+    if ((0, import_node_fs27.existsSync)(transcriptPath)) return transcriptPath;
   }
   return void 0;
 }
@@ -94914,7 +95758,7 @@ function parseNativeHookEnvelope(input2) {
   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 resolvedCwd = cwd ? (0, import_node_path28.resolve)(cwd) : void 0;
+  const resolvedCwd = cwd ? (0, import_node_path29.resolve)(cwd) : void 0;
   const transcriptPath = eventType === "subagent_start" || eventType === "subagent_end" ? stringField4(
     payload,
     "agent_transcript_path",
@@ -94960,7 +95804,7 @@ function parseNativeHookEnvelope(input2) {
     ...(eventType === "subagent_start" || eventType === "subagent_end") && parentSessionId ? { parentExternalSessionId: parentSessionId } : {},
     ...resolvedCwd ? { cwd: resolvedCwd } : {},
     ...projectPin,
-    ...transcriptPath ? { transcriptPath: (0, import_node_path28.resolve)(transcriptPath) } : {},
+    ...transcriptPath ? { transcriptPath: (0, import_node_path29.resolve)(transcriptPath) } : {},
     ...cursor ? { sourceCursor: cursor } : {},
     providerPayload
   };
@@ -95007,7 +95851,7 @@ function readBoundedHookPayload(fd = 0, maxBytes = MAX_NATIVE_HOOK_STDIN_BYTES)
   let totalBytes = 0;
   while (true) {
     const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, maxBytes + 1 - totalBytes));
-    const bytesRead = (0, import_node_fs26.readSync)(fd, chunk, 0, chunk.byteLength, null);
+    const bytesRead = (0, import_node_fs27.readSync)(fd, chunk, 0, chunk.byteLength, null);
     if (bytesRead === 0) break;
     totalBytes += bytesRead;
     if (totalBytes > maxBytes) throw new Error(`hook input exceeds ${maxBytes} bytes`);
@@ -95090,7 +95934,7 @@ function collectNativeIntegrationStatus(args = []) {
   const config2 = readConfig();
   const configPath = getConfigPath();
   const env = getDaemonCliEnvironment();
-  const homeDir = (0, import_node_os16.homedir)();
+  const homeDir = (0, import_node_os17.homedir)();
   return NATIVE_SESSION_PROVIDER_CAPABILITIES.map((capability) => ({
     provider: capability.providerKind,
     command: capability.command,
@@ -95119,7 +95963,7 @@ function decodeResumeFallbackContext(encoded) {
 }
 
 // src/sandbox.ts
-var import_node_os17 = require("os");
+var import_node_os18 = require("os");
 
 // src/execution-activity-tracker.ts
 var ExecutionActivityTracker = class {
@@ -95733,7 +96577,7 @@ var agentProbeAckSchema = external_exports.object({
 
 // src/sandbox-outbox.ts
 var import_node_crypto23 = require("crypto");
-var import_node_fs27 = require("fs");
+var import_node_fs28 = require("fs");
 function deriveSandboxOutboxKey(sessionToken) {
   if (!sessionToken) {
     throw new Error("sandbox event outbox requires ALAN_SESSION_TOKEN for key derivation");
@@ -95754,24 +96598,24 @@ function assertValidOutboxKey(key, path2) {
 }
 function loadOrCreateSandboxOutboxKey(input2) {
   const keyPath = sandboxOutboxKeyPath(input2.spoolPath);
-  if ((0, import_node_fs27.existsSync)(keyPath)) {
-    (0, import_node_fs27.chmodSync)(keyPath, 384);
-    return assertValidOutboxKey((0, import_node_fs27.readFileSync)(keyPath, "utf8").trim(), keyPath);
+  if ((0, import_node_fs28.existsSync)(keyPath)) {
+    (0, import_node_fs28.chmodSync)(keyPath, 384);
+    return assertValidOutboxKey((0, import_node_fs28.readFileSync)(keyPath, "utf8").trim(), keyPath);
   }
   const initialKey = deriveSandboxOutboxKey(input2.sessionToken);
   try {
-    (0, import_node_fs27.writeFileSync)(keyPath, initialKey, { encoding: "utf8", flag: "wx", mode: 384 });
+    (0, import_node_fs28.writeFileSync)(keyPath, initialKey, { encoding: "utf8", flag: "wx", mode: 384 });
     return initialKey;
   } catch (error61) {
     if (error61.code !== "EEXIST") throw error61;
-    (0, import_node_fs27.chmodSync)(keyPath, 384);
-    return assertValidOutboxKey((0, import_node_fs27.readFileSync)(keyPath, "utf8").trim(), keyPath);
+    (0, import_node_fs28.chmodSync)(keyPath, 384);
+    return assertValidOutboxKey((0, import_node_fs28.readFileSync)(keyPath, "utf8").trim(), keyPath);
   }
 }
 function quarantineUnusableOutbox(path2) {
   const suffix = `corrupt-${Date.now()}-${process.pid}`;
   for (const candidate of [path2, eventJournalDir(path2)]) {
-    if ((0, import_node_fs27.existsSync)(candidate)) (0, import_node_fs27.renameSync)(candidate, `${candidate}.${suffix}`);
+    if ((0, import_node_fs28.existsSync)(candidate)) (0, import_node_fs28.renameSync)(candidate, `${candidate}.${suffix}`);
   }
 }
 function createSandboxEventOutbox(input2) {
@@ -96183,6 +97027,7 @@ var WSClient = class {
           providerSessionId: data.providerSessionId,
           resumeFallbackContext: data.resumeFallbackContext,
           backendKind: data.backendKind,
+          providerApiKey: data.providerApiKey,
           agentId: data.agentId,
           agentPrompt: data.agentPrompt,
           selectedModel: data.selectedModel,
@@ -96200,7 +97045,10 @@ var WSClient = class {
           cloudEnvironmentId: data.cloudEnvironmentId,
           conversationId: data.conversationId,
           teamId: data.teamId,
-          currentUser: data.currentUser
+          currentUser: data.currentUser,
+          terminalContextRefs: data.terminalContextRefs,
+          terminalSnapshots: data.terminalSnapshots,
+          externalMcpServers: data.externalMcpServers
         };
         const acceptDelivery = () => {
           if (data.messageId) this.rememberAcceptedMessageId(data.messageId);
@@ -96224,6 +97072,9 @@ var WSClient = class {
     this.socket.on("stop", () => {
       callbacks.onStop();
     });
+    this.socket.on("agent.abort", (data) => {
+      callbacks.onAbort?.({ runId: data?.runId, reason: data?.reason });
+    });
     this.socket.on("tool_response", (data) => {
       if (data?.toolId && typeof data.response === "string") {
         callbacks.onToolResponse?.(data.toolId, data.response);
@@ -96281,6 +97132,7 @@ async function runSandbox(config2) {
   let currentTaskMeta;
   let currentPrMeta;
   let currentWorkflowTools;
+  let currentExternalMcpServers;
   let currentMaxIterations = config2.maxIterations ?? 50;
   let currentTaskId = config2.taskId;
   let currentConversationId = config2.sessionId;
@@ -96375,6 +97227,14 @@ async function runSandbox(config2) {
         lifecycle.info("sandbox_agent_stop_received");
         stopActiveAgent();
       },
+      onAbort: ({ runId, reason }) => {
+        if (runId && currentRunId && runId !== currentRunId) {
+          lifecycle.info("sandbox_agent_abort_ignored_stale_run", { runId, currentRunId });
+          return;
+        }
+        lifecycle.info("sandbox_agent_abort_received", { runId, reason });
+        stopActiveAgent(reason === "watchdog_timeout" ? "watchdog_timeout" : "user");
+      },
       onToolResponse: (toolId, response) => {
         if (currentAgent) {
           const sent = currentAgent.sendToolResponse(toolId, response);
@@ -96431,7 +97291,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_os17.homedir)() });
+  const runtimeSkillManager = await RuntimeSkillManager.open({ homeDirectory: (0, import_node_os18.homedir)() });
   let lastProviderSessionId = config2.providerSessionId;
   let resumeFallbackContext = config2.resumeFallbackContext;
   let activeBackendKind = config2.backendKind || "claude_cli";
@@ -96571,6 +97431,7 @@ async function runSandbox(config2) {
           resumeFallbackContext,
           taskMeta: currentTaskMeta,
           prMeta: currentPrMeta,
+          externalMcpServers: currentExternalMcpServers,
           taskId: currentTaskId,
           conversationId: currentConversationId,
           alanMcp: currentAlanMcp,
@@ -96688,6 +97549,7 @@ async function runSandbox(config2) {
       activeMode = nextPayload.mode;
     }
     currentAlanMcp = nextPayload.alanMcp;
+    currentExternalMcpServers = nextPayload.externalMcpServers;
     if (nextPayload.taskMeta !== void 0) {
       currentTaskMeta = nextPayload.taskMeta;
     }
@@ -96728,616 +97590,6 @@ async function runSandbox(config2) {
   wsClient.close();
 }
 
-// src/service-manager.ts
-var import_node_child_process9 = require("child_process");
-var import_node_fs28 = require("fs");
-var import_node_os18 = require("os");
-var import_node_path29 = require("path");
-var SERVICE_LABEL = "ai.tryalan.agent";
-var SYSTEMD_UNIT = "alan-agent.service";
-var WINDOWS_TASK = "Alan Agent";
-function xml(value2) {
-  return value2.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
-function systemdArg(value2) {
-  return `"${value2.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
-}
-function powershellLiteral(value2) {
-  return `'${value2.replaceAll("'", "''")}'`;
-}
-function serviceNames(profile) {
-  if (profile === "production") {
-    return { launchd: SERVICE_LABEL, systemd: SYSTEMD_UNIT, windows: WINDOWS_TASK };
-  }
-  const suffix = profile === "custom" ? "prod" : profile;
-  const title = `${suffix[0]?.toUpperCase()}${suffix.slice(1)}`;
-  return {
-    launchd: `${SERVICE_LABEL}.${suffix}`,
-    systemd: `alan-agent-${suffix}.service`,
-    windows: `${WINDOWS_TASK} ${title}`
-  };
-}
-function buildDaemonServicePlan(input2) {
-  const daemonArgs = [input2.nodeExecutable, input2.cliEntry, "daemon", "--profile", input2.profile];
-  const names = serviceNames(input2.profile);
-  if (input2.platform === "darwin") {
-    const userId = input2.userId ?? process.getuid?.();
-    if (userId === void 0) throw new Error("Cannot determine the current macOS user ID");
-    const domain2 = `gui/${userId}`;
-    const serviceTarget = `${domain2}/${names.launchd}`;
-    const manifestPath = (0, import_node_path29.join)(input2.homeDir, "Library", "LaunchAgents", `${names.launchd}.plist`);
-    const logDir = (0, import_node_path29.join)(resolveAgentConfigDirectory(input2.profile, input2.homeDir), "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");
-    const environmentBlock = environmentEntries ? `  <key>EnvironmentVariables</key>
-  <dict>
-${environmentEntries}
-  </dict>
-` : "";
-    const manifest = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${names.launchd}</string>
-  <key>ProgramArguments</key>
-  <array>
-${programArguments}
-  </array>
-${environmentBlock}  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <dict>
-    <key>SuccessfulExit</key>
-    <false/>
-  </dict>
-  <key>ThrottleInterval</key>
-  <integer>5</integer>
-  <key>StandardOutPath</key>
-  <string>${xml((0, import_node_path29.join)(logDir, "daemon.log"))}</string>
-  <key>StandardErrorPath</key>
-  <string>${xml((0, import_node_path29.join)(logDir, "daemon-error.log"))}</string>
-</dict>
-</plist>
-`;
-    return {
-      platform: "darwin",
-      manifestPath,
-      manifest,
-      logDirectory: logDir,
-      loadDefinitionCommands: [
-        {
-          command: "launchctl",
-          args: ["bootstrap", domain2, manifestPath],
-          tolerateFailure: true
-        }
-      ],
-      reloadDefinitionCommands: [
-        {
-          command: "launchctl",
-          args: ["bootout", domain2, manifestPath],
-          tolerateFailure: true
-        },
-        {
-          command: "launchctl",
-          args: ["bootstrap", domain2, manifestPath],
-          tolerateFailure: false
-        }
-      ],
-      enableCommands: [
-        {
-          command: "launchctl",
-          args: ["enable", serviceTarget],
-          tolerateFailure: true
-        }
-      ],
-      startCommands: [
-        {
-          command: "launchctl",
-          args: ["kickstart", serviceTarget],
-          tolerateFailure: false
-        }
-      ],
-      stopCommands: [
-        {
-          command: "launchctl",
-          args: ["kill", "SIGTERM", serviceTarget],
-          tolerateFailure: true
-        }
-      ],
-      replaceCommands: [
-        {
-          command: "launchctl",
-          args: ["bootout", domain2, manifestPath],
-          tolerateFailure: true
-        },
-        {
-          command: "launchctl",
-          args: ["bootstrap", domain2, manifestPath],
-          tolerateFailure: false
-        },
-        {
-          command: "launchctl",
-          args: ["kickstart", "-k", serviceTarget],
-          tolerateFailure: false
-        }
-      ],
-      uninstallCommands: [
-        {
-          command: "launchctl",
-          args: ["bootout", domain2, manifestPath],
-          tolerateFailure: true
-        }
-      ],
-      statusCommand: {
-        command: "launchctl",
-        args: ["print", serviceTarget],
-        tolerateFailure: true
-      },
-      isActiveCommand: {
-        command: "launchctl",
-        args: ["print", serviceTarget],
-        tolerateFailure: true
-      },
-      lingerStatusCommand: null
-    };
-  }
-  if (input2.platform === "linux") {
-    const manifestPath = (0, import_node_path29.join)(input2.homeDir, ".config", "systemd", "user", names.systemd);
-    const environmentLines = Object.entries(input2.environment ?? {}).map(([key, value2]) => `Environment=${systemdArg(`${key}=${value2}`)}`).join("\n");
-    const manifest = `[Unit]
-Description=Alan local agent daemon
-After=network-online.target
-Wants=network-online.target
-StartLimitIntervalSec=300
-StartLimitBurst=3
-
-[Service]
-Type=simple
-${environmentLines ? `${environmentLines}
-` : ""}ExecStart=${daemonArgs.map(systemdArg).join(" ")}
-Restart=on-failure
-RestartSec=5
-
-[Install]
-WantedBy=default.target
-`;
-    return {
-      platform: "linux",
-      manifestPath,
-      manifest,
-      logDirectory: null,
-      loadDefinitionCommands: [
-        {
-          command: "systemctl",
-          args: ["--user", "daemon-reload"],
-          tolerateFailure: false
-        }
-      ],
-      reloadDefinitionCommands: [
-        {
-          command: "systemctl",
-          args: ["--user", "daemon-reload"],
-          tolerateFailure: false
-        }
-      ],
-      enableCommands: [
-        {
-          command: "systemctl",
-          args: ["--user", "enable", names.systemd],
-          tolerateFailure: false
-        }
-      ],
-      startCommands: [
-        {
-          command: "systemctl",
-          args: ["--user", "start", names.systemd],
-          tolerateFailure: false
-        }
-      ],
-      stopCommands: [
-        {
-          command: "systemctl",
-          args: ["--user", "stop", names.systemd],
-          tolerateFailure: true
-        }
-      ],
-      replaceCommands: [
-        {
-          command: "systemctl",
-          args: ["--user", "daemon-reload"],
-          tolerateFailure: false
-        },
-        {
-          command: "systemctl",
-          args: ["--user", "restart", names.systemd],
-          tolerateFailure: false
-        }
-      ],
-      uninstallCommands: [
-        {
-          command: "systemctl",
-          args: ["--user", "disable", "--now", names.systemd],
-          tolerateFailure: true
-        },
-        {
-          command: "systemctl",
-          args: ["--user", "daemon-reload"],
-          tolerateFailure: false
-        }
-      ],
-      statusCommand: {
-        command: "systemctl",
-        args: ["--user", "status", names.systemd, "--no-pager"],
-        tolerateFailure: true
-      },
-      isActiveCommand: {
-        command: "systemctl",
-        args: ["--user", "is-active", names.systemd],
-        tolerateFailure: true
-      },
-      lingerStatusCommand: {
-        command: "loginctl",
-        args: ["show-user", "$(id -un)", "-p", "Linger"],
-        tolerateFailure: true
-      }
-    };
-  }
-  const environmentPrefix = Object.entries(input2.environment ?? {}).map(([key, value2]) => `$env:${key} = ${powershellLiteral(value2)}`).join("; ");
-  const directArgument = [input2.cliEntry, "daemon", "--profile", input2.profile].map((part) => part.includes(" ") ? `"${part}"` : part).join(" ");
-  const executable = powershellLiteral(environmentPrefix ? "powershell.exe" : input2.nodeExecutable);
-  const argument = powershellLiteral(
-    environmentPrefix ? `-NoProfile -NonInteractive -WindowStyle Hidden -Command "${environmentPrefix}; & ${powershellLiteral(input2.nodeExecutable)} ${powershellLiteral(input2.cliEntry)} daemon --profile ${input2.profile}"` : directArgument
-  );
-  const registerScript = [
-    "$currentUser = [System.Security.Principal.WindowsIdentity]::GetCurrent().Name",
-    `$action = New-ScheduledTaskAction -Execute ${executable} -Argument ${argument}`,
-    "$trigger = New-ScheduledTaskTrigger -AtLogOn -User $currentUser",
-    "$principal = New-ScheduledTaskPrincipal -UserId $currentUser -LogonType Interactive -RunLevel Limited",
-    "$settings = New-ScheduledTaskSettingsSet -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1) -ExecutionTimeLimit ([TimeSpan]::Zero)",
-    `Register-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Force | Out-Null`
-  ].join("; ");
-  return {
-    platform: "win32",
-    manifestPath: null,
-    manifest: null,
-    logDirectory: null,
-    loadDefinitionCommands: [
-      {
-        command: "powershell.exe",
-        args: ["-NoProfile", "-NonInteractive", "-Command", registerScript],
-        tolerateFailure: false
-      }
-    ],
-    reloadDefinitionCommands: [
-      {
-        command: "powershell.exe",
-        args: ["-NoProfile", "-NonInteractive", "-Command", registerScript],
-        tolerateFailure: false
-      }
-    ],
-    enableCommands: [],
-    startCommands: [
-      {
-        command: "powershell.exe",
-        args: [
-          "-NoProfile",
-          "-NonInteractive",
-          "-Command",
-          `Start-ScheduledTask -TaskName ${powershellLiteral(names.windows)}`
-        ],
-        tolerateFailure: false
-      }
-    ],
-    stopCommands: [
-      {
-        command: "powershell.exe",
-        args: [
-          "-NoProfile",
-          "-NonInteractive",
-          "-Command",
-          `Stop-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -ErrorAction SilentlyContinue`
-        ],
-        tolerateFailure: true
-      }
-    ],
-    replaceCommands: [
-      {
-        command: "powershell.exe",
-        args: [
-          "-NoProfile",
-          "-NonInteractive",
-          "-Command",
-          `${registerScript}; Start-ScheduledTask -TaskName ${powershellLiteral(names.windows)}`
-        ],
-        tolerateFailure: false
-      }
-    ],
-    uninstallCommands: [
-      {
-        command: "powershell.exe",
-        args: [
-          "-NoProfile",
-          "-NonInteractive",
-          "-Command",
-          `Unregister-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -Confirm:$false -ErrorAction SilentlyContinue`
-        ],
-        tolerateFailure: true
-      }
-    ],
-    statusCommand: {
-      command: "powershell.exe",
-      args: [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        `Get-ScheduledTask -TaskName ${powershellLiteral(names.windows)} | Format-List TaskName,State`
-      ],
-      tolerateFailure: true
-    },
-    isActiveCommand: {
-      command: "powershell.exe",
-      args: [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        `(Get-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -ErrorAction SilentlyContinue).State`
-      ],
-      tolerateFailure: true
-    },
-    lingerStatusCommand: null
-  };
-}
-function resolveCurrentPlatform() {
-  const currentPlatform = (0, import_node_os18.platform)();
-  if (currentPlatform !== "darwin" && currentPlatform !== "linux" && currentPlatform !== "win32") {
-    throw new Error(`Daemon service installation is not supported on ${currentPlatform}`);
-  }
-  return currentPlatform;
-}
-function currentServicePlan(args, runtime) {
-  const currentPlatform = resolveCurrentPlatform();
-  const profile = resolveEndpointProfileFromArgs(args);
-  const cliEntry = runtime?.cliEntry ?? process.argv[1];
-  if (!cliEntry) throw new Error("Cannot determine the alan-agent executable path");
-  return buildDaemonServicePlan({
-    platform: currentPlatform,
-    homeDir: (0, import_node_os18.homedir)(),
-    nodeExecutable: runtime?.executable ?? process.execPath,
-    cliEntry: (0, import_node_path29.resolve)(cliEntry),
-    profile,
-    environment: runtime?.environment
-  });
-}
-function writeManifestAtomic(path2, contents) {
-  (0, import_node_fs28.mkdirSync)((0, import_node_path29.dirname)(path2), { recursive: true, mode: 448 });
-  const pendingPath = `${path2}.pending-${process.pid}`;
-  try {
-    (0, import_node_fs28.writeFileSync)(pendingPath, contents, { mode: 384 });
-    (0, import_node_fs28.chmodSync)(pendingPath, 384);
-    (0, import_node_fs28.renameSync)(pendingPath, path2);
-  } finally {
-    (0, import_node_fs28.rmSync)(pendingPath, { force: true });
-  }
-}
-function defaultReadManifest(path2) {
-  if (!(0, import_node_fs28.existsSync)(path2)) return null;
-  return (0, import_node_fs28.readFileSync)(path2, "utf8");
-}
-function runServiceCommand(command) {
-  const result = (0, import_node_child_process9.spawnSync)(command.command, command.args, { encoding: "utf8", shell: false });
-  const status = result.status ?? 1;
-  const output2 = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
-  if (status !== 0 && !command.tolerateFailure) {
-    throw new Error(
-      `Service command failed (${command.command} ${command.args.join(" ")}): ${output2 || `exit ${status}`}`
-    );
-  }
-  return { status, output: output2 };
-}
-function defaultSleep(ms) {
-  return new Promise((resolveSleep) => {
-    setTimeout(resolveSleep, ms);
-  });
-}
-function parseServiceHostState(servicePlatform, result) {
-  const output2 = result.output;
-  if (servicePlatform === "linux") {
-    const trimmed = output2.trim().toLowerCase();
-    if (trimmed === "inactive" || trimmed === "failed" || trimmed === "dead" || /\binactive\b/i.test(output2) || /\bfailed\b/i.test(output2)) {
-      return "stopped";
-    }
-  }
-  if (result.status !== 0) return "unknown";
-  if (servicePlatform === "darwin") {
-    if (/\bstate\s*=\s*running\b/i.test(output2)) return "running";
-    if (/\bstate\s*=\s*(not running|waiting|stopped)\b/i.test(output2)) return "stopped";
-    if (/\bpid\s*=\s*[1-9]\d*\b/i.test(output2)) return "running";
-    if (/could not find service/i.test(output2)) return "stopped";
-    return "unknown";
-  }
-  if (servicePlatform === "linux") {
-    const trimmed = output2.trim().toLowerCase();
-    if (trimmed === "active" || /\bactive\s*\(running\)/i.test(output2)) return "running";
-    if (trimmed === "activating" || trimmed === "reloading") return "starting";
-    return "unknown";
-  }
-  const stateMatch = output2.match(/\b(?:State|state)\s*[:=]\s*(\w+)/);
-  const state = (stateMatch?.[1] ?? output2.trim()).toLowerCase();
-  if (state === "running") return "running";
-  if (state === "ready" || state === "disabled" || state === "queued") return "stopped";
-  return "unknown";
-}
-function resolveEnsureDefinitionOutcome(input2) {
-  if (!input2.definitionChanged) {
-    return { changed: false, updatePending: false };
-  }
-  if (input2.hostState === "running" || input2.hostState === "starting") {
-    return { changed: true, updatePending: true };
-  }
-  return { changed: true, updatePending: false };
-}
-function shouldStartOnInstall(hostState) {
-  return hostState === "stopped";
-}
-function resolveUsername(options) {
-  if (options?.username) return options.username;
-  try {
-    return (0, import_node_os18.userInfo)().username;
-  } catch {
-    return process.env.USER || process.env.USERNAME || "unknown";
-  }
-}
-function buildLingerStatusCommand(username) {
-  return {
-    command: "loginctl",
-    args: ["show-user", username, "-p", "Linger"],
-    tolerateFailure: true
-  };
-}
-function assertSystemdUserLingerEnabled(options = {}) {
-  const username = resolveUsername(options);
-  const run = options.runCommand ?? runServiceCommand;
-  const result = run(buildLingerStatusCommand(username));
-  if (result.status !== 0) {
-    throw new Error(
-      `Cannot verify systemd user linger for ${username} (loginctl failed). For durable headless VM boot run: sudo loginctl enable-linger ${username}`
-    );
-  }
-  if (!/Linger=yes/i.test(result.output)) {
-    throw new Error(
-      `systemd user linger is disabled for ${username}. For durable headless VM boot run: sudo loginctl enable-linger ${username}`
-    );
-  }
-}
-function createHostContext(options = {}) {
-  const args = options.args ?? [];
-  const plan = currentServicePlan(args, options.runtime);
-  const run = options.runCommand ?? runServiceCommand;
-  const sleep4 = options.sleep ?? defaultSleep;
-  const nowMs = options.nowMs ?? Date.now;
-  const readManifest = options.readManifest ?? defaultReadManifest;
-  const writeManifest = options.writeManifest ?? writeManifestAtomic;
-  const removeManifest = options.removeManifest ?? ((path2) => (0, import_node_fs28.rmSync)(path2, { force: true }));
-  const ensureLogDir = options.ensureLogDir ?? (() => {
-    if (plan.logDirectory) (0, import_node_fs28.mkdirSync)(plan.logDirectory, { recursive: true, mode: 448 });
-  });
-  return {
-    args,
-    plan,
-    run,
-    sleep: sleep4,
-    nowMs,
-    readManifest,
-    writeManifest,
-    removeManifest,
-    ensureLogDir,
-    profile: resolveEndpointProfileFromArgs(args)
-  };
-}
-function inspectDaemonService(options = {}) {
-  const { plan, run, nowMs } = createHostContext(options);
-  const result = run(plan.isActiveCommand);
-  const state = parseServiceHostState(plan.platform, result);
-  return {
-    state,
-    platform: plan.platform,
-    detail: result.output || void 0,
-    observedAtMs: nowMs()
-  };
-}
-function ensureDaemonServiceDefinition(options = {}) {
-  const ctx = createHostContext(options);
-  const { plan, run, readManifest, writeManifest, ensureLogDir } = ctx;
-  let definitionChanged = false;
-  if (plan.manifestPath && plan.manifest) {
-    ensureLogDir();
-    const existing = readManifest(plan.manifestPath);
-    definitionChanged = existing !== plan.manifest;
-    if (definitionChanged) {
-      writeManifest(plan.manifestPath, plan.manifest);
-    }
-  } else if (plan.platform === "win32") {
-    definitionChanged = true;
-  }
-  const inspection = inspectDaemonService(options);
-  const outcome = resolveEnsureDefinitionOutcome({
-    definitionChanged,
-    hostState: inspection.state
-  });
-  if (outcome.updatePending) {
-    return outcome;
-  }
-  if (inspection.state === "running" || inspection.state === "starting") {
-    return outcome;
-  }
-  const definitionCommands = inspection.state === "stopped" ? plan.reloadDefinitionCommands : plan.loadDefinitionCommands;
-  for (const command of definitionCommands) run(command);
-  return outcome;
-}
-function enableDaemonService(options = {}) {
-  const { plan, run } = createHostContext(options);
-  for (const command of plan.enableCommands) run(command);
-}
-function startDaemonService(options = {}) {
-  const { plan, run } = createHostContext(options);
-  for (const command of plan.startCommands) run(command);
-}
-function uninstallDaemonService(args = [], options = {}) {
-  const ctx = createHostContext({ ...options, args: options.args ?? args });
-  for (const command of ctx.plan.uninstallCommands) ctx.run(command);
-  if (ctx.plan.manifestPath) ctx.removeManifest(ctx.plan.manifestPath);
-  console.info("[alan-agent] Per-user daemon service removed");
-}
-function installDaemonService(args = [], runtime, options = {}) {
-  const profile = resolveEndpointProfileFromArgs(args);
-  const configPath = resolveAgentConfigPath({ profile });
-  if (!configExistsAtPath(configPath)) {
-    throw new Error(`No ${profile} runtime is configured. Run alan-agent setup or login first.`);
-  }
-  const headless = options.headless ?? args.includes("--headless");
-  const merged = { ...options, args, runtime, headless };
-  const ctx = createHostContext(merged);
-  if (headless) {
-    if (ctx.plan.platform !== "linux") {
-      throw new Error("--headless is only supported on Linux systemd user services");
-    }
-    assertSystemdUserLingerEnabled(merged);
-  }
-  const ensured = ensureDaemonServiceDefinition(merged);
-  enableDaemonService(merged);
-  const inspection = inspectDaemonService(merged);
-  if (ensured.updatePending) {
-    console.info("[alan-agent] Daemon service definition update pending; leaving running service", {
-      profile,
-      state: inspection.state
-    });
-    return;
-  }
-  if (!shouldStartOnInstall(inspection.state)) {
-    console.info("[alan-agent] Per-user daemon service already present", {
-      profile,
-      state: inspection.state
-    });
-    return;
-  }
-  startDaemonService(merged);
-  console.info("[alan-agent] Per-user daemon service installed", { profile });
-}
-function printDaemonServiceStatus(args = []) {
-  const plan = currentServicePlan(args);
-  const result = runServiceCommand({ ...plan.statusCommand, tolerateFailure: true });
-  if (result.status !== 0) {
-    process.stdout.write(`unknown
-${result.output}
-`);
-    return;
-  }
-  process.stdout.write(`${result.output}
-`);
-}
-
 // src/skills/skill-cli.ts
 var import_promises6 = require("fs/promises");
 var import_node_os19 = require("os");
@@ -97536,13 +97788,7 @@ async function main() {
     return;
   }
   if (command === "install") {
-    bindConfigPath(commandArgs);
-    const configured = readConfig();
-    const configurationMode = resolveInstallConfigurationMode(commandArgs, configured);
-    const setup = configurationMode === "setup" ? await setupDaemon(commandArgs) : null;
-    if (configurationMode === "login") await loginWithDeviceCode(commandArgs);
-    if (!setup?.daemonAlreadyRunning) installDaemonService(commandArgs);
-    runMcpIntegrationCommand(["reconcile", ...commandArgs]);
+    await runInstallCommand(commandArgs);
     return;
   }
   if (command === "login") {