@hermespilot/link 0.6.0 → 0.6.2

package/dist/{chunk-UHYO4EJD.js → chunk-UBWRPRZ4.js}

@@ -1376,6 +1376,97 @@ var REASONING_EFFORTS = [
   "high",
   "xhigh"
 ];
+var EMPTY_AUTH_BACKED_PROVIDER_STATE = {
+  providers: /* @__PURE__ */ new Set(),
+  providerBaseUrls: /* @__PURE__ */ new Map(),
+  externalProviders: /* @__PURE__ */ new Set()
+};
+var AUTH_BACKED_MODEL_PROVIDERS = [
+  {
+    provider: "openai-codex",
+    providerName: "OpenAI Codex",
+    baseUrl: "https://chatgpt.com/backend-api/codex",
+    apiMode: "codex_responses",
+    authType: "oauth_external",
+    modelIds: [
+      "gpt-5.5",
+      "gpt-5.4-mini",
+      "gpt-5.4",
+      "gpt-5.3-codex",
+      "gpt-5.3-codex-spark",
+      "gpt-5.2-codex",
+      "gpt-5.1-codex-max",
+      "gpt-5.1-codex-mini"
+    ]
+  },
+  {
+    provider: "nous",
+    providerName: "Nous Research",
+    baseUrl: "https://inference-api.nousresearch.com/v1",
+    apiMode: "chat_completions",
+    authType: "oauth_device_code",
+    modelIds: [
+      "anthropic/claude-opus-4.7",
+      "anthropic/claude-sonnet-4.6",
+      "openai/gpt-5.5",
+      "openai/gpt-5.4-mini",
+      "openai/gpt-5.3-codex",
+      "google/gemini-3-pro-preview",
+      "qwen/qwen3.6-plus",
+      "minimax/minimax-m2.7"
+    ]
+  },
+  {
+    provider: "qwen-oauth",
+    providerName: "Qwen OAuth (Portal)",
+    baseUrl: "https://portal.qwen.ai/v1",
+    apiMode: "chat_completions",
+    authType: "oauth_external",
+    modelIds: [
+      "qwen3.6-plus",
+      "qwen3.5-plus",
+      "qwen3-coder-plus",
+      "qwen3-coder-next"
+    ]
+  },
+  {
+    provider: "google-gemini-cli",
+    providerName: "Google Gemini (OAuth)",
+    baseUrl: "cloudcode-pa://google",
+    apiMode: "chat_completions",
+    authType: "oauth_external",
+    modelIds: [
+      "gemini-3.1-pro-preview",
+      "gemini-3-pro-preview",
+      "gemini-3-flash-preview"
+    ]
+  },
+  {
+    provider: "minimax-oauth",
+    providerName: "MiniMax (OAuth)",
+    baseUrl: "https://api.minimax.io/anthropic",
+    apiMode: "anthropic_messages",
+    authType: "oauth_external",
+    modelIds: ["MiniMax-M2.7", "MiniMax-M2.7-highspeed"]
+  },
+  {
+    provider: "copilot",
+    providerName: "GitHub Copilot",
+    baseUrl: "https://api.githubcopilot.com",
+    apiMode: "chat_completions",
+    authType: "copilot",
+    modelIds: [
+      "gpt-5.4",
+      "gpt-5.4-mini",
+      "gpt-5.3-codex",
+      "claude-sonnet-4.6",
+      "gemini-3-pro-preview"
+    ]
+  }
+];
+var AUTH_BACKED_MODEL_PROVIDER_BY_KEY = new Map(
+  AUTH_BACKED_MODEL_PROVIDERS.map((provider) => [provider.provider, provider])
+);
 var PROFILE_PERMISSION_TOOLSETS = [
   {
     key: "web",
@@ -1632,11 +1723,13 @@ async function listHermesModelConfigs(profileName = "default", configPath = reso
   const env = await readHermesEnvFile(profileName);
   const defaultModel = readModelConfig(config.model).model ?? null;
   const defaultReasoningEffort = readProfileReasoningEffort(config);
+  const authBackedProviders = await readHermesAuthBackedProviderState(profileName);
   const models = readManagedModelConfigs(
     config,
     env,
     defaultModel,
-    defaultReasoningEffort
+    defaultReasoningEffort,
+    authBackedProviders
   );
   const compressionModelId = readAuxiliaryCompressionModelId(config);
   return {
@@ -1683,7 +1776,11 @@ async function listHermesModelConfigCatalog(input) {
         existing.isDefault = existing.isDefault || model.isDefault;
         if (existing.credentialState !== "configured" && model.credentialState === "configured") {
           existing.credentialState = "configured";
+          existing.credentialSource = model.credentialSource;
         }
+        existing.authType = existing.authType ?? model.authType;
+        existing.editable = existing.editable && model.editable;
+        existing.isReadOnly = existing.isReadOnly || model.isReadOnly;
         continue;
       }
       items.set(key, {
@@ -1695,6 +1792,10 @@ async function listHermesModelConfigCatalog(input) {
         ...model.contextLength ? { contextLength: model.contextLength } : {},
         ...model.keyEnv ? { keyEnv: model.keyEnv } : {},
         credentialState: model.credentialState,
+        credentialSource: model.credentialSource,
+        ...model.authType ? { authType: model.authType } : {},
+        editable: model.editable,
+        isReadOnly: model.isReadOnly,
         isDefault: model.isDefault,
         ...model.reasoningEffort ? { reasoningEffort: model.reasoningEffort } : {},
         reasoningSupport: model.reasoningSupport,
@@ -1922,15 +2023,23 @@ async function deleteHermesModelConfig(modelId, profileName = "default", configP
   }
   const { document, config, existingRaw } = await readHermesConfigDocument(configPath);
   const env = await readHermesEnvFile(profileName);
+  const authBackedProviders = await readHermesAuthBackedProviderState(profileName);
   const existingModels = readManagedModelConfigs(
     config,
     env,
     readModelConfig(config.model).model ?? null,
-    readProfileReasoningEffort(config)
+    readProfileReasoningEffort(config),
+    authBackedProviders
   );
-  if (!existingModels.some((model) => model.id === id)) {
+  const deletingModel = findManagedModelById(existingModels, id);
+  if (!deletingModel) {
     throw new Error(`model "${id}" is not configured`);
   }
+  if (deletingModel.isReadOnly) {
+    throw new Error(
+      `model "${id}" is managed by Hermes auth and has no Profile config to delete`
+    );
+  }
   if (existingModels.length <= 1) {
     throw new Error(
       "\u81F3\u5C11\u9700\u8981\u4FDD\u7559\u4E00\u4E2A\u6A21\u578B\uFF0C\u907F\u514D Hermes Agent \u6CA1\u6709\u53EF\u7528\u9ED8\u8BA4\u6A21\u578B\u3002"
@@ -1946,7 +2055,8 @@ async function deleteHermesModelConfig(modelId, profileName = "default", configP
       config,
       env,
       null,
-      readProfileReasoningEffort(config)
+      readProfileReasoningEffort(config),
+      authBackedProviders
     )[0];
     if (nextDefault) {
       writeDefaultModelConfig(modelConfig, {
@@ -1989,19 +2099,33 @@ async function deleteHermesModelConfig(modelId, profileName = "default", configP
 async function saveHermesModelDefaults(input, profileName = "default", configPath = resolveHermesConfigPath(profileName)) {
   const taskModelId = input.taskModelId?.trim();
   const compressionModelId = input.compressionModelId?.trim();
-  if (!taskModelId && !compressionModelId) {
-    throw new Error("taskModelId or compressionModelId is required");
+  const reasoningEffort = input.reasoningEffort ? normalizeReasoningEffort(input.reasoningEffort) : void 0;
+  if (input.reasoningEffort && !reasoningEffort) {
+    throw new Error(
+      "reasoningEffort must be none, minimal, low, medium, high or xhigh"
+    );
+  }
+  if (!taskModelId && !compressionModelId && !reasoningEffort) {
+    throw new Error(
+      "taskModelId, compressionModelId or reasoningEffort is required"
+    );
   }
   const { document, config, existingRaw } = await readHermesConfigDocument(configPath);
   const env = await readHermesEnvFile(profileName);
+  const authBackedProviders = await readHermesAuthBackedProviderState(profileName);
   if (taskModelId) {
     const models = readManagedModelConfigs(
       config,
       env,
       readModelConfig(config.model).model ?? null,
-      readProfileReasoningEffort(config)
+      readProfileReasoningEffort(config),
+      authBackedProviders
     );
-    const selected = findManagedModelById(models, taskModelId);
+    const selected = findManagedModel(models, {
+      id: taskModelId,
+      provider: input.taskModelProvider,
+      baseUrl: input.taskModelBaseUrl
+    });
     if (!selected) {
       throw new Error(`model "${taskModelId}" is not configured`);
     }
@@ -2027,14 +2151,22 @@ async function saveHermesModelDefaults(input, profileName = "default", configPat
       writeProfileReasoningEffort(config, selected.reasoningEffort);
     }
   }
+  if (reasoningEffort) {
+    writeProfileReasoningEffort(config, reasoningEffort);
+  }
   if (compressionModelId) {
     const models = readManagedModelConfigs(
       config,
       env,
       readModelConfig(config.model).model ?? null,
-      readProfileReasoningEffort(config)
+      readProfileReasoningEffort(config),
+      authBackedProviders
     );
-    const selected = findManagedModelById(models, compressionModelId);
+    const selected = findManagedModel(models, {
+      id: compressionModelId,
+      provider: input.compressionModelProvider,
+      baseUrl: input.compressionModelBaseUrl
+    });
     if (!selected) {
       throw new Error(`model "${compressionModelId}" is not configured`);
     }
@@ -2501,7 +2633,7 @@ async function writeHermesConfigDocument(input) {
   );
   return backupPath;
 }
-function readManagedModelConfigs(config, env, defaultModel, defaultReasoningEffort) {
+function readManagedModelConfigs(config, env, defaultModel, defaultReasoningEffort, authBackedProviders = EMPTY_AUTH_BACKED_PROVIDER_STATE) {
   const models = [];
   const seen = /* @__PURE__ */ new Set();
   const seenEndpoint = /* @__PURE__ */ new Map();
@@ -2511,11 +2643,17 @@ function readManagedModelConfigs(config, env, defaultModel, defaultReasoningEffo
     const entry = toRecord(rawEntry);
     const providerName = readString2(entry.name) ?? readString2(entry.provider_name) ?? readString2(entry.provider_key) ?? "Custom Provider";
     const provider = readString2(entry.provider_key) ?? readString2(entry.provider) ?? "custom";
-    const baseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api) ?? "";
+    const authDefinition = AUTH_BACKED_MODEL_PROVIDER_BY_KEY.get(provider);
+    const baseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api) ?? authDefinition?.baseUrl ?? "";
     const apiMode = inferApiMode(provider, baseUrl, readString2(entry.api_mode));
     const contextLength = readPositiveInteger(entry.context_length);
     const keyEnv = readString2(entry.key_env) ?? parseEnvReference(readString2(entry.api_key));
-    const credentialState = readCredentialState(entry, env);
+    const credentialMetadata = readEntryCredentialMetadata(
+      entry,
+      env,
+      provider,
+      authBackedProviders
+    );
     for (const id of readEntryModelIds(entry)) {
       const key = modelConfigKey(provider, baseUrl, id);
       if (seen.has(key)) {
@@ -2540,8 +2678,8 @@ function readManagedModelConfigs(config, env, defaultModel, defaultReasoningEffo
         apiMode,
         ...modelContextLength ? { contextLength: modelContextLength } : {},
         ...keyEnv ? { keyEnv } : {},
-        credentialConfigured: credentialState === "configured",
-        credentialState,
+        credentialConfigured: credentialMetadata.credentialState === "configured",
+        ...credentialMetadata,
         isDefault: id === defaultModel,
         ...reasoningEffort ? { reasoningEffort } : {},
         ...reasoningMetadata
@@ -2551,7 +2689,8 @@ function readManagedModelConfigs(config, env, defaultModel, defaultReasoningEffo
   }
   if (defaultModel) {
     const provider = modelConfig.provider ?? "default";
-    const baseUrl = modelConfig.baseUrl ?? "";
+    const authDefinition = AUTH_BACKED_MODEL_PROVIDER_BY_KEY.get(provider);
+    const baseUrl = modelConfig.baseUrl ?? authDefinition?.baseUrl ?? "";
     const endpointMatchIndex = seenEndpoint.get(
       modelEndpointKey(baseUrl, defaultModel)
     );
@@ -2565,39 +2704,263 @@ function readManagedModelConfigs(config, env, defaultModel, defaultReasoningEffo
         isDefault: true,
         reasoningEffort: existing.reasoningEffort ?? defaultReasoningEffort ?? void 0
       };
-      return models.sort(
-        (left, right) => Number(right.isDefault) - Number(left.isDefault)
-      );
+    } else {
+      const key = modelConfigKey(provider, baseUrl, defaultModel);
+      if (!seen.has(key)) {
+        const credentialMetadata = readModelCredentialMetadata(
+          modelConfig,
+          env,
+          provider,
+          authBackedProviders
+        );
+        const reasoningEffort = modelConfig.reasoningEffort ?? defaultReasoningEffort;
+        const apiMode = inferApiMode(provider, baseUrl, modelConfig.apiMode);
+        models.unshift({
+          id: defaultModel,
+          provider,
+          providerName: authDefinition?.providerName ?? provider,
+          source: "model_default",
+          baseUrl,
+          apiMode,
+          ...modelConfig.contextLength ? { contextLength: modelConfig.contextLength } : {},
+          ...modelConfig.keyEnv ? { keyEnv: modelConfig.keyEnv } : {},
+          credentialConfigured: credentialMetadata.credentialState === "configured",
+          ...credentialMetadata,
+          isDefault: true,
+          ...reasoningEffort ? { reasoningEffort } : {},
+          ...modelReasoningMetadata({
+            provider,
+            baseUrl,
+            modelId: defaultModel,
+            apiMode
+          })
+        });
+        seen.add(key);
+        seenEndpoint.set(modelEndpointKey(baseUrl, defaultModel), 0);
+      }
     }
-    const key = modelConfigKey(provider, baseUrl, defaultModel);
-    if (!seen.has(key)) {
-      const credentialState = readModelCredentialState(modelConfig, env);
-      const reasoningEffort = modelConfig.reasoningEffort ?? defaultReasoningEffort;
-      models.unshift({
-        id: defaultModel,
-        provider,
-        providerName: provider,
-        source: "model_default",
+  }
+  appendAuthBackedModelConfigs({
+    models,
+    seen,
+    seenEndpoint,
+    defaultModel,
+    defaultProvider: modelConfig.provider ?? null,
+    defaultReasoningEffort,
+    authBackedProviders
+  });
+  return models.sort(
+    (left, right) => Number(right.isDefault) - Number(left.isDefault)
+  );
+}
+function appendAuthBackedModelConfigs(input) {
+  for (const definition of AUTH_BACKED_MODEL_PROVIDERS) {
+    if (!input.authBackedProviders.providers.has(definition.provider)) {
+      continue;
+    }
+    const baseUrl = input.authBackedProviders.providerBaseUrls.get(definition.provider) ?? definition.baseUrl;
+    const credentialSource = input.authBackedProviders.externalProviders.has(
+      definition.provider
+    ) ? "external_auth" : "auth_store";
+    for (const id of definition.modelIds) {
+      const key = modelConfigKey(definition.provider, baseUrl, id);
+      if (input.seen.has(key)) {
+        continue;
+      }
+      input.seen.add(key);
+      const apiMode = inferApiMode(
+        definition.provider,
         baseUrl,
-        apiMode: inferApiMode(provider, baseUrl, modelConfig.apiMode),
-        ...modelConfig.contextLength ? { contextLength: modelConfig.contextLength } : {},
-        ...modelConfig.keyEnv ? { keyEnv: modelConfig.keyEnv } : {},
-        credentialConfigured: credentialState === "configured",
-        credentialState,
-        isDefault: true,
-        ...reasoningEffort ? { reasoningEffort } : {},
+        definition.apiMode
+      );
+      const isDefault = id === input.defaultModel && definition.provider === input.defaultProvider;
+      input.models.push({
+        id,
+        provider: definition.provider,
+        providerName: definition.providerName,
+        source: "auth_store",
+        baseUrl,
+        apiMode,
+        credentialConfigured: true,
+        credentialState: "configured",
+        credentialSource,
+        authType: definition.authType,
+        editable: false,
+        isReadOnly: true,
+        isDefault,
+        ...isDefault && input.defaultReasoningEffort ? { reasoningEffort: input.defaultReasoningEffort } : {},
         ...modelReasoningMetadata({
-          provider,
+          provider: definition.provider,
           baseUrl,
-          modelId: defaultModel,
-          apiMode: inferApiMode(provider, baseUrl, modelConfig.apiMode)
+          modelId: id,
+          apiMode
         })
       });
+      input.seenEndpoint.set(
+        modelEndpointKey(baseUrl, id),
+        input.models.length - 1
+      );
     }
   }
-  return models.sort(
-    (left, right) => Number(right.isDefault) - Number(left.isDefault)
+}
+function readEntryCredentialMetadata(entry, env, provider, authBackedProviders) {
+  const apiKey = readString2(entry.api_key);
+  const keyEnv = readString2(entry.key_env) ?? parseEnvReference(apiKey);
+  return readCredentialMetadata({
+    provider,
+    inlineApiKey: apiKey && !parseEnvReference(apiKey) ? apiKey : void 0,
+    keyEnv,
+    env,
+    authBackedProviders
+  });
+}
+function readModelCredentialMetadata(model, env, provider, authBackedProviders) {
+  return readCredentialMetadata({
+    provider,
+    inlineApiKey: model.apiKey && !model.keyEnv ? model.apiKey : void 0,
+    keyEnv: model.keyEnv,
+    env,
+    authBackedProviders
+  });
+}
+function readCredentialMetadata(input) {
+  const definition = AUTH_BACKED_MODEL_PROVIDER_BY_KEY.get(input.provider);
+  if (definition) {
+    const configured = input.authBackedProviders.providers.has(input.provider);
+    return {
+      credentialState: configured ? "configured" : "missing",
+      credentialSource: input.authBackedProviders.externalProviders.has(
+        input.provider
+      ) ? "external_auth" : "auth_store",
+      authType: definition.authType,
+      editable: false,
+      isReadOnly: true
+    };
+  }
+  if (input.inlineApiKey?.trim()) {
+    return {
+      credentialState: "configured",
+      credentialSource: "api_key",
+      editable: true,
+      isReadOnly: false
+    };
+  }
+  if (input.keyEnv) {
+    return {
+      credentialState: input.env[input.keyEnv]?.trim() ? "configured" : "missing",
+      credentialSource: "env",
+      editable: true,
+      isReadOnly: false
+    };
+  }
+  return {
+    credentialState: "unknown",
+    credentialSource: "unknown",
+    editable: true,
+    isReadOnly: false
+  };
+}
+async function readHermesAuthBackedProviderState(profileName) {
+  const providers = /* @__PURE__ */ new Set();
+  const providerBaseUrls = /* @__PURE__ */ new Map();
+  const externalProviders = /* @__PURE__ */ new Set();
+  const profileDir = resolveHermesProfileDir(profileName);
+  const authStore = await readJsonRecordFile(path3.join(profileDir, "auth.json"));
+  const storeProviders = toRecord(authStore.providers);
+  for (const [provider, rawState] of Object.entries(storeProviders)) {
+    if (!AUTH_BACKED_MODEL_PROVIDER_BY_KEY.has(provider)) {
+      continue;
+    }
+    const state = toRecord(rawState);
+    if (!authRecordHasUsableCredential(state)) {
+      continue;
+    }
+    providers.add(provider);
+    const baseUrl = readAuthRecordBaseUrl(state);
+    if (baseUrl) {
+      providerBaseUrls.set(provider, baseUrl);
+    }
+  }
+  const credentialPool = toRecord(authStore.credential_pool);
+  for (const [provider, rawEntries] of Object.entries(credentialPool)) {
+    if (!AUTH_BACKED_MODEL_PROVIDER_BY_KEY.has(provider)) {
+      continue;
+    }
+    if (!Array.isArray(rawEntries)) {
+      continue;
+    }
+    const entry = rawEntries.map(toRecord).find((candidate) => authRecordHasUsableCredential(candidate));
+    if (!entry) {
+      continue;
+    }
+    providers.add(provider);
+    const baseUrl = readAuthRecordBaseUrl(entry);
+    if (baseUrl) {
+      providerBaseUrls.set(provider, baseUrl);
+    }
+  }
+  if (await hasQwenCliAuth()) {
+    providers.add("qwen-oauth");
+    externalProviders.add("qwen-oauth");
+  }
+  if (await hasGoogleGeminiCliAuth(profileDir)) {
+    providers.add("google-gemini-cli");
+    externalProviders.add("google-gemini-cli");
+  }
+  return { providers, providerBaseUrls, externalProviders };
+}
+async function readJsonRecordFile(filePath) {
+  const raw = await readFile2(filePath, "utf8").catch((error) => {
+    if (isNodeError3(error, "ENOENT")) {
+      return null;
+    }
+    throw error;
+  });
+  if (!raw) {
+    return {};
+  }
+  try {
+    return toRecord(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+function authRecordHasUsableCredential(record) {
+  const credentialKeys = [
+    "access",
+    "access_token",
+    "api_key",
+    "runtime_api_key",
+    "agent_key",
+    "refresh",
+    "refresh_token"
+  ];
+  if (credentialKeys.some((key) => readString2(record[key])?.trim())) {
+    return true;
+  }
+  const tokens = toRecord(record.tokens);
+  return credentialKeys.some((key) => readString2(tokens[key])?.trim());
+}
+function readAuthRecordBaseUrl(record) {
+  const direct = readString2(record.inference_base_url) ?? readString2(record.base_url) ?? readString2(record.portal_base_url);
+  if (direct?.trim()) {
+    return direct.trim();
+  }
+  const tokens = toRecord(record.tokens);
+  const nested = readString2(tokens.inference_base_url) ?? readString2(tokens.base_url) ?? readString2(tokens.portal_base_url);
+  return nested?.trim() || void 0;
+}
+async function hasQwenCliAuth() {
+  const qwenAuth = await readJsonRecordFile(
+    path3.join(os.homedir(), ".qwen", "oauth_creds.json")
+  );
+  return authRecordHasUsableCredential(qwenAuth);
+}
+async function hasGoogleGeminiCliAuth(profileDir) {
+  const googleAuth = await readJsonRecordFile(
+    path3.join(profileDir, "auth", "google_oauth.json")
   );
+  return authRecordHasUsableCredential(googleAuth);
 }
 function readAuxiliaryCompressionModelId(config) {
   const auxiliary = toRecord(config.auxiliary);
@@ -2633,6 +2996,22 @@ function resolveCompressionModel(config, models) {
 function findManagedModelById(models, id) {
   return models.find((model) => model.id === id);
 }
+function findManagedModel(models, input) {
+  const provider = input.provider?.trim();
+  const baseUrl = input.baseUrl?.trim();
+  return models.find((model) => {
+    if (model.id !== input.id) {
+      return false;
+    }
+    if (provider && model.provider !== provider) {
+      return false;
+    }
+    if (baseUrl !== void 0 && normalizeBaseUrl(model.baseUrl) !== normalizeBaseUrl(baseUrl)) {
+      return false;
+    }
+    return true;
+  });
+}
 function writeAuxiliaryCompressionModelConfig(config, model, env) {
   const auxiliary = ensureRecord(config, "auxiliary");
   const compression = ensureRecord(auxiliary, "compression");
@@ -2969,11 +3348,15 @@ async function readHermesModelConfigForImport(input) {
     resolveHermesConfigPath(input.profileName)
   );
   const env = await readHermesEnvFile(input.profileName);
+  const authBackedProviders = await readHermesAuthBackedProviderState(
+    input.profileName
+  );
   const models = readManagedModelConfigs(
     config,
     env,
     readModelConfig(config.model).model ?? null,
-    readProfileReasoningEffort(config)
+    readProfileReasoningEffort(config),
+    authBackedProviders
   );
   const model = models.find((candidate) => {
     if (candidate.id !== input.modelId) {
@@ -3038,26 +3421,6 @@ function compareCatalogItems(left, right) {
   }
   return left.id.localeCompare(right.id);
 }
-function readCredentialState(entry, env) {
-  const apiKey = readString2(entry.api_key);
-  const keyEnv = readString2(entry.key_env) ?? parseEnvReference(apiKey);
-  if (apiKey && !parseEnvReference(apiKey)) {
-    return "configured";
-  }
-  if (!keyEnv) {
-    return "unknown";
-  }
-  return env[keyEnv]?.trim() ? "configured" : "missing";
-}
-function readModelCredentialState(model, env) {
-  if (model.apiKey && !model.keyEnv) {
-    return "configured";
-  }
-  if (!model.keyEnv) {
-    return "unknown";
-  }
-  return env[model.keyEnv]?.trim() ? "configured" : "missing";
-}
 function modelConfigKey(provider, baseUrl, modelId) {
   return [provider, normalizeBaseUrl(baseUrl), modelId].join("\n").toLowerCase();
 }
@@ -4425,7 +4788,7 @@ async function listCronOutputFiles(profileName, jobId) {
       mtimeMs: fileStat.mtimeMs
     });
   }
-  return files.sort((left, right) => left.mtimeMs - right.mtimeMs).map(({ path: path28, mtime }) => ({ path: path28, mtime }));
+  return files.sort((left, right) => left.mtimeMs - right.mtimeMs).map(({ path: path29, mtime }) => ({ path: path29, mtime }));
 }
 async function readCronOutput(outputPath) {
   const content = await readFile3(outputPath, "utf8");
@@ -4493,7 +4856,7 @@ import { setTimeout as delay } from "timers/promises";
 import { promisify as promisify2 } from "util";
 
 // src/runtime/logger.ts
-import { appendFile, mkdir as mkdir4, open as open2, readFile as readFile4, rename as rename2, rm as rm2, stat as stat3 } from "fs/promises";
+import { appendFile, mkdir as mkdir4, open as open2, readFile as readFile4, rename as rename2, rm as rm2, stat as stat3, truncate } from "fs/promises";
 import os3 from "os";
 import path6 from "path";
 
@@ -4502,7 +4865,7 @@ import os2 from "os";
 import path5 from "path";
 
 // src/constants.ts
-var LINK_VERSION = "0.6.0";
+var LINK_VERSION = "0.6.2";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -4719,6 +5082,27 @@ function readRecentGatewayLogEntries(options = {}) {
     filePaths: options.filePaths ?? getGatewayLogFiles(paths)
   });
 }
+async function flushLogFiles(options) {
+  const maxFiles = Math.max(0, Math.floor(options.maxFiles ?? DEFAULT_MAX_FILES));
+  const truncated = [];
+  const removed = [];
+  const filePaths = Array.from(new Set(options.filePaths.map((filePath) => path6.resolve(filePath))));
+  for (const filePath of filePaths) {
+    if (await fileExists(filePath)) {
+      await truncate(filePath, 0);
+      truncated.push(filePath);
+    }
+    for (let index = 1; index <= maxFiles; index += 1) {
+      const rotated = rotatedLogFile(filePath, index);
+      if (!await fileExists(rotated)) {
+        continue;
+      }
+      await rm2(rotated, { force: true });
+      removed.push(rotated);
+    }
+  }
+  return { truncated, removed };
+}
 function clampLimit(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
     return DEFAULT_READ_LIMIT;
@@ -4871,6 +5255,10 @@ async function moveIfExists(from, to) {
     }
   });
 }
+async function fileExists(filePath) {
+  const info = await stat3(filePath).catch(() => null);
+  return Boolean(info?.isFile());
+}
 function rotatedLogFile(filePath, index) {
   return `${filePath}.${index}`;
 }
@@ -5415,15 +5803,15 @@ ${stderr}`.trim();
     });
   });
 }
-function assertHermesRunsApiSupported(version, status) {
+function assertHermesRunsApiSupported(version, status, endpoint = "/v1/runs") {
   if (status !== 404) {
     return;
   }
   const versionText = version?.version ? `\u5F53\u524D\u68C0\u6D4B\u5230 Hermes Agent ${version.version}\u3002` : "";
   throw new LinkHttpError(
     502,
-    "hermes_runs_api_unsupported",
-    `${versionText}\u5F53\u524D Hermes Agent API Server \u4E0D\u652F\u6301 HermesPilot \u9700\u8981\u7684 /v1/runs \u63A5\u53E3\uFF0C\u8BF7\u5148\u8FD0\u884C \`hermes update\` \u5347\u7EA7 Hermes Agent\u3002`
+    endpoint === "/v1/runs" ? "hermes_runs_api_unsupported" : "hermes_api_endpoint_unsupported",
+    `${versionText}\u5F53\u524D Hermes Agent API Server \u4E0D\u652F\u6301 HermesPilot \u9700\u8981\u7684 ${endpoint} \u63A5\u53E3\uFF0C\u8BF7\u5148\u8FD0\u884C \`hermes update\` \u5347\u7EA7 Hermes Agent\u3002`
   );
 }
 async function startHermesGatewayOnce(paths, profileName, logger) {
@@ -5527,7 +5915,7 @@ async function restartHermesGatewayServiceIfAvailable(options) {
     "LaunchAgents",
     "ai.hermes.gateway.plist"
   );
-  if (!await fileExists(launchdPlistPath)) {
+  if (!await fileExists2(launchdPlistPath)) {
     return null;
   }
   try {
@@ -5598,7 +5986,7 @@ function buildHermesGatewayChildEnv() {
   }
   return env;
 }
-async function fileExists(filePath) {
+async function fileExists2(filePath) {
   return access(filePath).then(() => true).catch(() => false);
 }
 async function waitForHermesApiHealth(config, fetcher, timeoutMs) {
@@ -9378,10 +9766,25 @@ var ConversationOrchestrationCoordinator = class {
         if (isConversationNotFoundError(failError)) {
           return;
         }
-        throw failError;
+        await this.deps.logger.error("conversation_run_fail_mark_failed", {
+          conversation_id: conversationId,
+          run_id: runId,
+          error: failError instanceof Error ? failError.message : String(failError)
+        });
       }
     }).finally(() => {
-      void this.startNextQueuedRun(conversationId);
+      void this.startNextQueuedRun(conversationId).catch((error) => {
+        void this.deps.logger.warn("conversation_queue_drain_failed", {
+          conversation_id: conversationId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }).catch((error) => {
+      void this.deps.logger.error("conversation_run_worker_unhandled", {
+        conversation_id: conversationId,
+        run_id: runId,
+        error: error instanceof Error ? error.message : String(error)
+      });
     });
   }
   async startNextQueuedRunLocked(conversationId) {
@@ -9917,6 +10320,12 @@ function isConversationNotFoundError(error) {
 
 // src/conversations/agent-events.ts
 import { createHash as createHash3 } from "crypto";
+var APP_TOOL_EVENT_FIELDS_TO_DROP = /* @__PURE__ */ new Set([
+  "output",
+  "content",
+  "result",
+  "message"
+]);
 function projectConversationAgentEvent(event) {
   if (!isAgentActivityEvent(event.type)) {
     return null;
@@ -9925,8 +10334,7 @@ function projectConversationAgentEvent(event) {
     type: event.type,
     payload: event.payload ?? {},
     createdAt: event.created_at,
-    fallbackKey: String(event.seq),
-    raw: event.raw
+    fallbackKey: String(event.seq)
   });
 }
 function projectAgentEvent(input) {
@@ -9942,18 +10350,16 @@ function projectAgentEvent(input) {
   const id = readString7(input.payload, "tool_call_id") ?? readString7(input.payload, "toolCallId") ?? readString7(input.payload, "call_id") ?? readString7(input.payload, "id") ?? readString7(tool, "id") ?? readString7(call, "id") ?? readString7(fn, "id") ?? `tool_${hashAgentEventKey(`${type}:${input.fallbackKey}:${stableStringify(input.payload)}`)}`;
   const rawArguments = input.payload.arguments ?? input.payload.args ?? input.payload.input ?? tool.arguments ?? tool.args ?? tool.input ?? call.arguments ?? call.args ?? call.input ?? fn.arguments;
   const args = stringifyAgentValue(rawArguments);
-  const output = stringifyAgentValue(
-    input.payload.result ?? input.payload.output ?? input.payload.content ?? input.payload.message ?? tool.result ?? tool.output ?? call.result ?? call.output
-  );
   const summary = readString7(input.payload, "summary") ?? readString7(input.payload, "description") ?? readText(input.payload, "preview") ?? readString7(tool, "summary") ?? readString7(tool, "description") ?? readString7(call, "summary") ?? void 0;
   const status = input.payload.error === true ? "failed" : agentStatusForEventType(type);
-  const detail = status === "failed" ? readErrorMessage(input.payload) ?? output ?? summary ?? args ?? void 0 : status === "completed" ? output ?? summary ?? args ?? void 0 : args ?? summary ?? void 0;
-  const subtitle = summarizeAgentArguments({
+  const actionSummary = summarizeAgentArguments({
     toolName: name,
     rawArguments,
     summary,
     args
-  }) ?? (status === "running" ? `\u6B63\u5728\u8C03\u7528 ${name}` : status === "completed" ? `${name} \u5DF2\u5B8C\u6210` : `${name} \u6267\u884C\u5931\u8D25`);
+  });
+  const detail = status === "failed" ? readErrorMessage(input.payload) ?? actionSummary ?? void 0 : actionSummary ?? void 0;
+  const subtitle = actionSummary ?? (status === "running" ? `\u6B63\u5728\u8C03\u7528 ${name}` : status === "completed" ? `${name} \u5DF2\u5B8C\u6210` : `${name} \u6267\u884C\u5931\u8D25`);
   return {
     id,
     title: humanizeToolName(name),
@@ -9963,10 +10369,23 @@ function projectAgentEvent(input) {
     created_at: createdAt,
     ...status === "running" ? {} : {
       completed_at: readString7(input.payload, "completed_at") ?? input.createdAt
-    },
-    ...input.raw ? { raw: input.raw } : {}
+    }
+  };
+}
+function projectAppConversationEvent(event) {
+  const { raw: _raw, ...baseEvent } = event;
+  if (!event.payload) {
+    return baseEvent;
+  }
+  return {
+    ...baseEvent,
+    payload: sanitizeAppConversationEventPayload(event.type, event.payload)
   };
 }
+function sanitizePersistedAgentEventProjection(event) {
+  const { raw: _raw, ...baseEvent } = event;
+  return baseEvent;
+}
 function isAgentActivityEvent(type) {
   return type.startsWith("tool.");
 }
@@ -10017,6 +10436,7 @@ function upsertAgentEventProjection(events, next) {
     next.subtitle,
     next.title
   );
+  const keepPreviousTerminalDetail = previous.detail !== void 0 && next.status !== "running" && next.status !== "info";
   const status = next.status === "running" && previous.status !== "running" ? previous.status : next.status;
   const merged = {
     ...previous,
@@ -10026,7 +10446,7 @@ function upsertAgentEventProjection(events, next) {
     title: isGenericToolTitle(next.title) ? previous.title : next.title,
     created_at: earliestTimestamp(previous.created_at, next.created_at),
     subtitle: nextSubtitleIsFallback ? previous.subtitle ?? next.subtitle : next.subtitle ?? previous.subtitle,
-    detail: next.detail ?? previous.detail,
+    detail: keepPreviousTerminalDetail ? previous.detail : next.detail ?? previous.detail,
     completed_at: next.completed_at ?? previous.completed_at
   };
   const copy = [...events];
@@ -10053,7 +10473,47 @@ function isToolStatusFallbackSubtitle(value, title) {
     return false;
   }
   const normalized = value.trim().toLowerCase();
-  return normalized.startsWith("\u6B63\u5728\u8C03\u7528 ") || normalized.endsWith(" \u5DF2\u5B8C\u6210") || normalized.endsWith(" \u6267\u884C\u5931\u8D25") || normalized === "tool" || normalized === "running";
+  const normalizedTitle = title.trim().toLowerCase();
+  return compactToolStatusText(normalized) === compactToolStatusText(normalizedTitle) || normalized.startsWith("\u6B63\u5728\u8C03\u7528 ") || normalized.endsWith(" \u5DF2\u5B8C\u6210") || normalized.endsWith(" \u6267\u884C\u5931\u8D25") || normalized === "tool" || normalized === "running";
+}
+function compactToolStatusText(value) {
+  return value.trim().toLowerCase().replace(/[\s_-]+/gu, "");
+}
+function sanitizeAppConversationEventPayload(type, payload) {
+  return sanitizeAppConversationEventValue(payload, {
+    dropRootFields: isToolCompletedEvent(type) ? APP_TOOL_EVENT_FIELDS_TO_DROP : null,
+    depth: 0
+  });
+}
+function sanitizeAppConversationEventValue(value, input) {
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => sanitizeAppConversationEventValue(item, {
+        dropRootFields: input.dropRootFields,
+        depth: input.depth + 1
+      })
+    );
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const next = {};
+  for (const [key, child] of Object.entries(toRecord6(value))) {
+    if (key === "raw") {
+      continue;
+    }
+    if (input.depth === 0 && input.dropRootFields?.has(key)) {
+      continue;
+    }
+    next[key] = sanitizeAppConversationEventValue(child, {
+      dropRootFields: input.dropRootFields,
+      depth: input.depth + 1
+    });
+  }
+  return next;
+}
+function isToolCompletedEvent(type) {
+  return type.toLowerCase() === "tool.completed";
 }
 function closeRunningAgentEvents(events, status, completedAt) {
   if (!events?.length) {
@@ -10088,7 +10548,44 @@ function summarizeAgentArguments(input) {
   if (skillViewSummary) {
     return skillViewSummary;
   }
-  return compactAgentSummary(input.summary ?? input.args);
+  const argumentSummary = summarizeGenericToolArguments(
+    input.rawArguments,
+    input.args
+  );
+  if (argumentSummary) {
+    return argumentSummary;
+  }
+  if (input.summary && compactToolText(input.summary) !== compactToolText(input.toolName)) {
+    return compactAgentSummary(input.summary);
+  }
+  return void 0;
+}
+function summarizeGenericToolArguments(rawArguments, args) {
+  const argumentObject = readToolArgumentsObject(rawArguments, args);
+  const entries = Object.entries(argumentObject).filter(([, value]) => value !== void 0 && value !== null).slice(0, 3);
+  if (entries.length > 0) {
+    return compactAgentSummary(
+      entries.map(([key, value]) => {
+        const text = stringifyAgentValue(value) ?? "";
+        return `${humanizeArgumentKey(key)}: ${text}`;
+      }).join(" \xB7 ")
+    );
+  }
+  const trimmed = args?.trim();
+  if (!trimmed || looksLikeJsonObject(trimmed)) {
+    return void 0;
+  }
+  return compactAgentSummary(trimmed);
+}
+function humanizeArgumentKey(value) {
+  return value.trim().replace(/([a-z0-9])([A-Z])/gu, "$1 $2").replace(/[_-]+/gu, " ").replace(/\s+/gu, " ").toLowerCase();
+}
+function compactToolText(value) {
+  return value.trim().toLowerCase().replace(/[\s_-]+/gu, "");
+}
+function looksLikeJsonObject(value) {
+  const trimmed = value.trim();
+  return trimmed.startsWith("{") && trimmed.endsWith("}");
 }
 function summarizeSkillViewArguments(toolName, rawArguments, args) {
   const normalizedToolName = toolName.trim().toLowerCase().replace(/[\s-]+/gu, "_");
@@ -10416,9 +10913,7 @@ var ConversationQueryCoordinator = class {
         return message;
       }
       const fromLog = eventsByMessageId.get(message.id) ?? [];
-      const persisted = (message.agent_events ?? []).filter(
-        isMeaningfulAgentEventProjection
-      );
+      const persisted = (message.agent_events ?? []).filter(isMeaningfulAgentEventProjection).map(sanitizePersistedAgentEventProjection);
       const agentEvents = mergeAgentEventProjections(fromLog, persisted);
       return agentEvents.length > 0 ? {
         ...message,
@@ -10503,8 +10998,9 @@ function hydrateAgentEventBlocks(blocks, agentEvents) {
     return {
       ...block,
       events: block.events.map((event) => {
+        const appEvent = sanitizePersistedAgentEventProjection(event);
         const hydrated = agentEventById.get(event.id);
-        return hydrated ? upsertAgentEventProjection([event], hydrated)[0] ?? event : event;
+        return hydrated ?? appEvent;
       })
     };
   });
@@ -12947,10 +13443,24 @@ async function streamHermesResponses(input, options = {}) {
       options
     );
   }
+  if (response.status === 404 && input.previous_response_id) {
+    const message = await readUpstreamErrorMessage(
+      response,
+      "Previous Hermes response was not found"
+    );
+    if (/previous response not found|response not found/iu.test(message)) {
+      throw new LinkHttpError(
+        409,
+        "hermes_previous_response_not_found",
+        message
+      );
+    }
+  }
   if (response.status === 404 || response.status === 503) {
     assertHermesRunsApiSupported(
       await readHermesVersion({ logger: options.logger }).catch(() => null),
-      response.status
+      response.status,
+      "/v1/responses"
     );
     throw new LinkHttpError(
       503,
@@ -13085,10 +13595,10 @@ function parseHermesApiCapabilities(payload) {
     sessionKeyHeader: readString10(features, "session_key_header")
   };
 }
-async function callHermesApi(path28, init, options) {
+async function callHermesApi(path29, init, options) {
   const method = init.method ?? "GET";
   const startedAt = Date.now();
-  void options.logger?.debug("hermes_api_request_started", { method, path: path28 });
+  void options.logger?.debug("hermes_api_request_started", { method, path: path29 });
   const availability = await ensureHermesApiServerAvailable({
     fetchImpl: options.fetchImpl,
     logger: options.logger,
@@ -13096,7 +13606,7 @@ async function callHermesApi(path28, init, options) {
   });
   let config = availability.configResult.apiServer;
   const fetcher = options.fetchImpl ?? fetch;
-  const request = () => fetchHermesApi(fetcher, config, path28, init, options);
+  const request = () => fetchHermesApi(fetcher, config, path29, init, options);
   let response;
   try {
     response = await request();
@@ -13104,7 +13614,7 @@ async function callHermesApi(path28, init, options) {
     logHermesApiError(
       options.logger,
       method,
-      path28,
+      path29,
       options.profileName,
       startedAt,
       error
@@ -13115,7 +13625,7 @@ async function callHermesApi(path28, init, options) {
     logHermesApiResponse(
       options.logger,
       method,
-      path28,
+      path29,
       options.profileName,
       startedAt,
       response
@@ -13124,7 +13634,7 @@ async function callHermesApi(path28, init, options) {
   }
   void options.logger?.warn("hermes_api_request_retrying_after_401", {
     method,
-    path: path28,
+    path: path29,
     profile: options.profileName ?? "default",
     port: config.port ?? null,
     duration_ms: Date.now() - startedAt
@@ -13142,7 +13652,7 @@ async function callHermesApi(path28, init, options) {
     logHermesApiError(
       options.logger,
       method,
-      path28,
+      path29,
       options.profileName,
       startedAt,
       error
@@ -13152,7 +13662,7 @@ async function callHermesApi(path28, init, options) {
   logHermesApiResponse(
     options.logger,
     method,
-    path28,
+    path29,
     options.profileName,
     startedAt,
     response
@@ -13162,7 +13672,7 @@ async function callHermesApi(path28, init, options) {
   }
   void options.logger?.warn("hermes_api_request_repairing_after_401", {
     method,
-    path: path28,
+    path: path29,
     profile: options.profileName ?? "default",
     port: config.port ?? null,
     duration_ms: Date.now() - startedAt
@@ -13182,7 +13692,7 @@ async function callHermesApi(path28, init, options) {
     logHermesApiError(
       options.logger,
       method,
-      path28,
+      path29,
       options.profileName,
       startedAt,
       error
@@ -13192,21 +13702,21 @@ async function callHermesApi(path28, init, options) {
   logHermesApiResponse(
     options.logger,
     method,
-    path28,
+    path29,
     options.profileName,
     startedAt,
     response
   );
   return response;
 }
-async function fetchHermesApi(fetcher, config, path28, init, options) {
+async function fetchHermesApi(fetcher, config, path29, init, options) {
   const headers = new Headers(init.headers);
   headers.set("accept", headers.get("accept") ?? "application/json");
   if (config.key) {
     headers.set("x-api-key", config.key);
     headers.set("authorization", `Bearer ${config.key}`);
   }
-  return await fetcher(`http://127.0.0.1:${config.port}${path28}`, {
+  return await fetcher(`http://127.0.0.1:${config.port}${path29}`, {
     ...init,
     headers
   }).catch((error) => {
@@ -13215,10 +13725,10 @@ async function fetchHermesApi(fetcher, config, path28, init, options) {
     }
     void options.logger?.warn("hermes_api_server_connect_failed", {
       method: String(init.method ?? "GET").toUpperCase(),
-      path: path28,
+      path: path29,
       profile: options.profileName ?? "default",
       port: config.port ?? null,
-      url: `http://127.0.0.1:${config.port}${path28}`,
+      url: `http://127.0.0.1:${config.port}${path29}`,
       error: error instanceof Error ? error.message : String(error)
     });
     throw new LinkHttpError(
@@ -13228,10 +13738,10 @@ async function fetchHermesApi(fetcher, config, path28, init, options) {
     );
   });
 }
-function logHermesApiResponse(logger, method, path28, profileName, startedAt, response) {
+function logHermesApiResponse(logger, method, path29, profileName, startedAt, response) {
   const fields = {
     method,
-    path: path28,
+    path: path29,
     profile: profileName ?? "default",
     status: response.status,
     duration_ms: Date.now() - startedAt
@@ -13252,10 +13762,10 @@ async function logHermesApiFailureResponse(logger, fields, response) {
     ...upstreamError ? { upstream_error: upstreamError } : {}
   });
 }
-function logHermesApiError(logger, method, path28, profileName, startedAt, error) {
+function logHermesApiError(logger, method, path29, profileName, startedAt, error) {
   void logger?.warn("hermes_api_request_failed", {
     method,
-    path: path28,
+    path: path29,
     profile: profileName ?? "default",
     duration_ms: Date.now() - startedAt,
     ...error instanceof LinkHttpError ? { status: error.status, code: error.code } : {},
@@ -14078,24 +14588,29 @@ async function* parseSseResponse(response) {
   let buffer = "";
   for await (const chunk of response.body) {
     buffer += decoder.decode(chunk, { stream: true });
-    let separatorIndex = buffer.indexOf("\n\n");
-    while (separatorIndex >= 0) {
-      const block = buffer.slice(0, separatorIndex);
-      buffer = buffer.slice(separatorIndex + 2);
+    let separator = findSseBlockSeparator(buffer);
+    while (separator) {
+      const block = buffer.slice(0, separator.index);
+      buffer = buffer.slice(separator.index + separator.length);
       const parsed = parseSseBlock(block);
       if (parsed) {
         yield parsed;
       }
-      separatorIndex = buffer.indexOf("\n\n");
+      separator = findSseBlockSeparator(buffer);
     }
   }
+  buffer += decoder.decode();
   const trailing = parseSseBlock(buffer);
   if (trailing) {
     yield trailing;
   }
 }
+function findSseBlockSeparator(value) {
+  const match = /\r\n\r\n|\n\n|\r\r/u.exec(value);
+  return match ? { index: match.index, length: match[0].length } : null;
+}
 function parseSseBlock(block) {
-  const lines = block.split("\n");
+  const lines = block.split(/\r\n|\n|\r/u);
   let eventName = "";
   const data = [];
   for (const rawLine of lines) {
@@ -14155,7 +14670,7 @@ function resolveConversationRunBackend(env = process.env) {
   if (RUNS_BACKEND_VALUES.has(raw)) {
     return "runs";
   }
-  return "runs";
+  return "responses";
 }
 function isRunToolResultCompensationEnabled(env = process.env) {
   const raw = env.HERMESLINK_RUN_TOOL_RESULT_COMPENSATION?.trim().toLowerCase();
@@ -15158,7 +15673,14 @@ var ConversationRunLifecycle = class {
         runId,
         hermesSessionId
       );
-      const conversationHistory = await buildConversationHistory({
+      const previousResponseId = backend === "responses" ? findPreviousHermesResponseId(snapshot, run) : void 0;
+      if (previousResponseId) {
+        await this.updateRun(conversationId, runId, {
+          previous_response_id: previousResponseId
+        });
+      }
+      const shouldBuildConversationHistory = backend === "runs" || !previousResponseId;
+      let conversationHistory = shouldBuildConversationHistory ? await buildConversationHistory({
         paths: this.deps.paths,
         profileName: run.profile,
         hermesSessionId,
@@ -15175,29 +15697,31 @@ var ConversationRunLifecycle = class {
           source: "empty",
           diagnostics: emptyConversationHistoryDiagnostics("build_failed")
         };
-      });
-      await this.deps.logger.debug("conversation_history_built", {
-        conversation_id: conversationId,
-        run_id: runId,
-        source: conversationHistory.source,
-        message_count: conversationHistory.messages.length,
-        ...conversationHistory.diagnostics
-      });
-      const cronJobIdsBeforeRun = await this.readHermesCronJobIds(
-        run.profile
-      ).catch(() => null);
-      const resolvedInput = await this.resolveRunInput({
+      }) : {
+        messages: [],
+        source: "empty",
+        diagnostics: emptyConversationHistoryDiagnostics("no_history")
+      };
+      await this.deps.logger.debug(
+        shouldBuildConversationHistory ? "conversation_history_built" : "conversation_history_skipped_previous_response",
+        {
+          conversation_id: conversationId,
+          run_id: runId,
+          backend,
+          source: conversationHistory.source,
+          message_count: conversationHistory.messages.length,
+          ...conversationHistory.diagnostics
+        }
+      );
+      const cronJobIdsBeforeRun = await this.readHermesCronJobIds(
+        run.profile
+      ).catch(() => null);
+      const resolvedInput = await this.resolveRunInput({
         conversationId,
         run,
         fallbackInput: input,
         snapshot
       });
-      const previousResponseId = backend === "responses" ? findPreviousHermesResponseId(snapshot, run) : void 0;
-      if (previousResponseId) {
-        await this.updateRun(conversationId, runId, {
-          previous_response_id: previousResponseId
-        });
-      }
       const deliveryStagingDir = await prepareDeliveryStagingRunDir(
         this.deps.paths,
         conversationId,
@@ -15211,12 +15735,12 @@ var ConversationRunLifecycle = class {
         return void 0;
       });
       const instructions = buildRunInstructions(run, deliveryStagingDir);
-      const estimatedUsage = estimateContextUsage({
+      const estimatedUsage = shouldBuildConversationHistory ? estimateContextUsage({
         conversationHistory: conversationHistory.messages,
         currentInput: resolvedInput,
         instructions,
         contextWindow: run.context_window
-      });
+      }) : void 0;
       if (estimatedUsage) {
         await this.updateRun(conversationId, runId, { usage: estimatedUsage });
       }
@@ -15225,22 +15749,89 @@ var ConversationRunLifecycle = class {
         run.profile ?? "default"
       );
       if (backend === "responses") {
-        const response = await streamHermesResponses(
-          {
-            input: resolvedInput,
-            instructions,
-            session_id: hermesSessionId,
-            session_key: sessionKey,
-            model: run.model,
-            ...previousResponseId ? { previous_response_id: previousResponseId } : {},
-            ...conversationHistory.messages.length > 0 ? { conversation_history: conversationHistory.messages } : {}
-          },
-          {
-            logger: this.deps.logger,
-            profileName: run.profile,
-            signal: controller.signal
+        let response;
+        try {
+          response = await streamHermesResponses(
+            {
+              input: resolvedInput,
+              instructions,
+              session_id: hermesSessionId,
+              session_key: sessionKey,
+              model: run.model,
+              ...previousResponseId ? { previous_response_id: previousResponseId } : {},
+              ...conversationHistory.messages.length > 0 ? { conversation_history: conversationHistory.messages } : {}
+            },
+            {
+              logger: this.deps.logger,
+              profileName: run.profile,
+              signal: controller.signal
+            }
+          );
+        } catch (error) {
+          if (!previousResponseId || !isLinkHttpError(error) || error.code !== "hermes_previous_response_not_found") {
+            throw error;
           }
-        );
+          await this.deps.logger.warn(
+            "hermes_previous_response_missing_falling_back_to_history",
+            {
+              conversation_id: conversationId,
+              run_id: runId,
+              previous_response_id: previousResponseId,
+              error: error.message
+            }
+          );
+          await this.updateRun(conversationId, runId, {
+            previous_response_id: void 0
+          });
+          conversationHistory = await buildConversationHistory({
+            paths: this.deps.paths,
+            profileName: run.profile,
+            hermesSessionId,
+            snapshot,
+            run
+          }).catch(async (buildError) => {
+            await this.deps.logger.warn("conversation_history_build_failed", {
+              conversation_id: conversationId,
+              run_id: runId,
+              error: buildError instanceof Error ? buildError.message : String(buildError)
+            });
+            return {
+              messages: [],
+              source: "empty",
+              diagnostics: emptyConversationHistoryDiagnostics("build_failed")
+            };
+          });
+          await this.deps.logger.debug("conversation_history_built", {
+            conversation_id: conversationId,
+            run_id: runId,
+            backend,
+            source: conversationHistory.source,
+            message_count: conversationHistory.messages.length,
+            ...conversationHistory.diagnostics
+          });
+          const fallbackUsage = estimateContextUsage({
+            conversationHistory: conversationHistory.messages,
+            currentInput: resolvedInput,
+            instructions,
+            contextWindow: run.context_window
+          });
+          await this.updateRun(conversationId, runId, { usage: fallbackUsage });
+          response = await streamHermesResponses(
+            {
+              input: resolvedInput,
+              instructions,
+              session_id: hermesSessionId,
+              session_key: sessionKey,
+              model: run.model,
+              ...conversationHistory.messages.length > 0 ? { conversation_history: conversationHistory.messages } : {}
+            },
+            {
+              logger: this.deps.logger,
+              profileName: run.profile,
+              signal: controller.signal
+            }
+          );
+        }
         const responseSessionId = response.headers.get("x-hermes-session-id")?.trim();
         if (responseSessionId) {
           await this.rememberRunHermesSessionId(
@@ -15336,6 +15927,7 @@ var ConversationRunLifecycle = class {
     );
   }
   async failRun(conversationId, runId, message, source) {
+    await this.refreshRunHermesCompressionTip(conversationId, runId);
     return this.deps.withConversationLock(
       conversationId,
       () => this.failRunLocked(conversationId, runId, message, source)
@@ -15433,9 +16025,21 @@ var ConversationRunLifecycle = class {
       await this.cancelRunAfterAbort(input.conversationId, input.runId);
       return;
     }
-    if (input.backend === "responses" && !streamError && await this.runHasAssistantOutput(input.conversationId, input.runId)) {
+    const hasAssistantOutput = await this.runHasAssistantOutput(
+      input.conversationId,
+      input.runId
+    );
+    if (input.backend === "responses" && !streamError && hasAssistantOutput) {
       await this.completeRun(input.conversationId, input.runId);
     } else {
+      await this.deps.logger.warn("hermes_event_stream_ended_without_terminal", {
+        backend: input.backend,
+        conversation_id: input.conversationId,
+        run_id: input.runId,
+        ...input.hermesRunId ? { hermes_run_id: input.hermesRunId } : {},
+        has_assistant_output: hasAssistantOutput,
+        ...streamError ? { error: formatUnknownErrorMessage(streamError) } : {}
+      });
       await this.failRun(
         input.conversationId,
         input.runId,
@@ -16053,11 +16657,38 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
     return user ? messageRequestsAppDelivery(messageText(user)) : false;
   }
   async completeRun(conversationId, runId, source) {
+    await this.refreshRunHermesCompressionTip(conversationId, runId);
     return this.deps.withConversationLock(
       conversationId,
       () => this.completeRunLocked(conversationId, runId, source)
     );
   }
+  async refreshRunHermesCompressionTip(conversationId, runId) {
+    const snapshot = await this.deps.readSnapshot(conversationId).catch(() => null);
+    const run = snapshot?.runs.find((item) => item.id === runId);
+    if (!run?.hermes_session_id) {
+      return;
+    }
+    const compressionTip = await readHermesCompressionTip(
+      run.hermes_session_id,
+      this.deps.paths,
+      run.profile
+    ).catch(() => void 0);
+    if (!compressionTip || compressionTip === run.hermes_session_id) {
+      return;
+    }
+    await this.deps.logger.info("hermes_compression_tip_detected", {
+      conversation_id: conversationId,
+      run_id: runId,
+      previous_hermes_session_id: run.hermes_session_id,
+      hermes_session_id: compressionTip
+    });
+    await this.rememberRunHermesSessionId(
+      conversationId,
+      runId,
+      compressionTip
+    );
+  }
   async completeRunLocked(conversationId, runId, source) {
     let snapshot = await this.deps.readSnapshot(conversationId);
     let run = snapshot.runs.find((item) => item.id === runId);
@@ -16744,6 +17375,7 @@ var ConversationService = class {
       metadata: this.metadata,
       commandHandlers: this.commandHandlers,
       runLifecycle: this.runLifecycle,
+      logger: this.logger,
       withConversationLock: (conversationId, task) => this.withConversationLock(conversationId, task),
       appendEvent: (conversationId, input) => this.appendEvent(conversationId, input),
       resolveMessageAttachmentParts: (conversationId, attachments) => this.maintenance.resolveMessageAttachmentParts(
@@ -17262,7 +17894,14 @@ var ConversationService = class {
       reason: "cancelled by app"
     });
     if (result.run.status === "cancelled") {
-      void this.orchestration.startNextQueuedRun(conversationId);
+      void this.orchestration.startNextQueuedRun(conversationId).catch(
+        (error) => {
+          void this.logger.warn("conversation_queue_drain_failed", {
+            conversation_id: conversationId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      );
     }
     return result;
   }
@@ -18282,6 +18921,7 @@ function isLanHost(hostname) {
 // src/http/sse.ts
 var DEFAULT_SSE_RETRY_MS = 1e3;
 var DEFAULT_SSE_HEARTBEAT_MS = 15e3;
+var activeSseSockets = /* @__PURE__ */ new WeakSet();
 function beginSseStream(request, response, options = {}) {
   const retryMs = normalizeRetryMs(options.retryMs);
   const heartbeatMs = Math.max(1e3, options.heartbeatMs ?? DEFAULT_SSE_HEARTBEAT_MS);
@@ -18289,11 +18929,15 @@ function beginSseStream(request, response, options = {}) {
   response.setHeader("content-type", "text/event-stream; charset=utf-8");
   response.setHeader("cache-control", "no-store");
   response.setHeader("connection", "keep-alive");
+  activeSseSockets.add(request.socket);
   response.flushHeaders();
   writeSseRetry(response, retryMs);
   writeSseComment(response, options.initialComment ?? "connected");
   let closed = false;
   let heartbeat = null;
+  const onStreamError = () => {
+    cleanup();
+  };
   const cleanup = () => {
     if (closed) {
       return;
@@ -18305,9 +18949,18 @@ function beginSseStream(request, response, options = {}) {
     }
     request.off("close", cleanup);
     response.off("close", cleanup);
+    request.off("error", onStreamError);
+    response.off("error", onStreamError);
+    activeSseSockets.delete(request.socket);
     options.onClose?.();
     if (!response.writableEnded && !response.destroyed) {
-      response.end();
+      try {
+        response.end();
+      } catch (error) {
+        if (!isExpectedClientDisconnectError(error)) {
+          throw error;
+        }
+      }
     }
   };
   heartbeat = setInterval(() => {
@@ -18320,37 +18973,43 @@ function beginSseStream(request, response, options = {}) {
   heartbeat.unref();
   request.once("close", cleanup);
   response.once("close", cleanup);
+  request.once("error", onStreamError);
+  response.once("error", onStreamError);
   return cleanup;
 }
+function isActiveSseSocket(socket) {
+  return socket != null && activeSseSockets.has(socket);
+}
 function writeSseEvent(response, event) {
+  const appEvent = projectAppConversationEvent(event);
   writeJsonSseEvent(response, {
-    event: event.type,
-    data: event,
-    id: event.seq
+    event: appEvent.type,
+    data: appEvent,
+    id: appEvent.seq
   });
 }
 function writeJsonSseEvent(response, event) {
   if (event.retryMs != null) {
-    response.write(`retry: ${normalizeRetryMs(event.retryMs)}
+    writeResponse(response, `retry: ${normalizeRetryMs(event.retryMs)}
 `);
   }
   if (event.id != null && event.id !== "") {
-    response.write(`id: ${event.id}
+    writeResponse(response, `id: ${event.id}
 `);
   }
-  response.write(`event: ${event.event}
+  writeResponse(response, `event: ${event.event}
 `);
-  response.write(`data: ${JSON.stringify(event.data)}
+  writeResponse(response, `data: ${JSON.stringify(event.data)}
 
 `);
 }
 function writeSseComment(response, comment = "keep-alive") {
-  response.write(`: ${comment}
+  writeResponse(response, `: ${comment}
 
 `);
 }
 function writeSseRetry(response, retryMs) {
-  response.write(`retry: ${normalizeRetryMs(retryMs)}
+  writeResponse(response, `retry: ${normalizeRetryMs(retryMs)}
 
 `);
 }
@@ -18358,6 +19017,25 @@ function normalizeRetryMs(retryMs) {
   const parsed = Number.isFinite(retryMs) ? Math.trunc(retryMs) : DEFAULT_SSE_RETRY_MS;
   return parsed >= 0 ? parsed : DEFAULT_SSE_RETRY_MS;
 }
+function writeResponse(response, chunk) {
+  if (response.writableEnded || response.destroyed) {
+    return;
+  }
+  try {
+    response.write(chunk);
+  } catch (error) {
+    if (!isExpectedClientDisconnectError(error)) {
+      throw error;
+    }
+  }
+}
+function isExpectedClientDisconnectError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = String(error.code ?? "");
+  return code === "ECONNRESET" || code === "EPIPE" || code === "ECONNABORTED" || code === "ETIMEDOUT" || /(?:socket hang up|aborted|write after end)/iu.test(error.message);
+}
 
 // src/http/routes/conversations.ts
 function registerConversationRoutes(router, options) {
@@ -18838,12 +19516,22 @@ function encodeRfc5987Value(value) {
 }
 
 // src/http/middleware/error-handler.ts
+var INTERNAL_HEALTH_PROBE_HEADER = "x-hermes-link-internal-health-probe";
 function createHttpErrorMiddleware(logger) {
   return async (ctx, next) => {
     const startedAt = Date.now();
+    const shouldSkipRequestLog = isInternalHealthProbe(ctx);
+    let expectedClientDisconnect = false;
     try {
       await next();
     } catch (error) {
+      if (isExpectedClientDisconnectError2(error, {
+        sse: isSseRequestContext(ctx)
+      })) {
+        expectedClientDisconnect = true;
+        ctx.respond = false;
+        return;
+      }
       const profileError = error instanceof Error && error.message === "invalid profile name";
       const profileNotFound = error instanceof Error && error.message === "profile does not exist";
       const status = isLinkHttpError(error) ? error.status : profileError ? 400 : profileNotFound ? 404 : 500;
@@ -18856,28 +19544,57 @@ function createHttpErrorMiddleware(logger) {
           message: error instanceof Error ? error.message : "Internal error"
         }
       };
-      void logger.write(
-        status >= 500 ? "error" : "warn",
-        "http_request_failed",
-        {
+      if (!shouldSkipRequestLog) {
+        void logger.write(
+          status >= 500 ? "error" : "warn",
+          "http_request_failed",
+          {
+            method: ctx.method,
+            path: ctx.path,
+            query: ctx.querystring || null,
+            status,
+            code,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
+      }
+    } finally {
+      if (!shouldSkipRequestLog && !expectedClientDisconnect) {
+        void logger.info("http_request", {
           method: ctx.method,
           path: ctx.path,
-          query: ctx.querystring || null,
-          status,
-          code,
-          error: error instanceof Error ? error.message : String(error)
-        }
-      );
-    } finally {
-      void logger.info("http_request", {
-        method: ctx.method,
-        path: ctx.path,
-        status: ctx.status,
-        duration_ms: Date.now() - startedAt
-      });
+          status: ctx.status,
+          duration_ms: Date.now() - startedAt
+        });
+      }
     }
   };
 }
+function isInternalHealthProbe(ctx) {
+  return ctx.path === "/api/v1/bootstrap" && ctx.get(INTERNAL_HEALTH_PROBE_HEADER) === "1";
+}
+function isSseRequestContext(ctx) {
+  if (!ctx) {
+    return false;
+  }
+  return isSseRequestPath(ctx.path) || isActiveSseSocket(ctx.req.socket);
+}
+function isSseRequestPath(path29) {
+  if (!path29) {
+    return false;
+  }
+  return path29 === "/api/v1/conversations/events" || path29 === "/api/v1/profile-creation/events" || path29 === "/api/v1/hermes/update/events" || path29 === "/api/v1/link/update/events" || /^\/api\/v1\/conversations\/[^/]+\/events$/u.test(path29) || /^\/api\/v1\/runs\/[^/]+\/events$/u.test(path29);
+}
+function isExpectedClientDisconnectError2(error, options = {}) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = String(error.code ?? "");
+  if (code === "ECONNRESET" || code === "EPIPE" || code === "ECONNABORTED" || /(?:socket hang up|aborted|write after end)/iu.test(error.message)) {
+    return true;
+  }
+  return options.sse === true && (code === "ETIMEDOUT" || /\b(?:read\s+)?ETIMEDOUT\b/iu.test(error.message));
+}
 
 // src/hermes/profiles.ts
 import { execFile as execFile4 } from "child_process";
@@ -19855,7 +20572,12 @@ function readModelConfigInput(body) {
 function readModelDefaultsInput(body) {
   return {
     taskModelId: readString16(body, "task_model_id") ?? readString16(body, "taskModelId") ?? readString16(body, "default_model_id") ?? readString16(body, "defaultModelId") ?? void 0,
-    compressionModelId: readString16(body, "compression_model_id") ?? readString16(body, "compressionModelId") ?? void 0
+    taskModelProvider: readString16(body, "task_model_provider") ?? readString16(body, "taskModelProvider") ?? readString16(body, "default_model_provider") ?? readString16(body, "defaultModelProvider") ?? void 0,
+    taskModelBaseUrl: readString16(body, "task_model_base_url") ?? readString16(body, "taskModelBaseUrl") ?? readString16(body, "default_model_base_url") ?? readString16(body, "defaultModelBaseUrl") ?? void 0,
+    compressionModelId: readString16(body, "compression_model_id") ?? readString16(body, "compressionModelId") ?? void 0,
+    compressionModelProvider: readString16(body, "compression_model_provider") ?? readString16(body, "compressionModelProvider") ?? void 0,
+    compressionModelBaseUrl: readString16(body, "compression_model_base_url") ?? readString16(body, "compressionModelBaseUrl") ?? void 0,
+    reasoningEffort: readString16(body, "reasoning_effort") ?? readString16(body, "reasoningEffort") ?? readString16(body, "default_reasoning_effort") ?? readString16(body, "defaultReasoningEffort") ?? void 0
   };
 }
 function readModelConfigImportInput(body) {
@@ -19958,85 +20680,392 @@ import { EventEmitter as EventEmitter2 } from "events";
 import {
   cp,
   mkdir as mkdir11,
-  readFile as readFile14,
+  readFile as readFile15,
   rm as rm6,
-  stat as stat14
+  stat as stat15
 } from "fs/promises";
+import path22 from "path";
+import YAML4 from "yaml";
+
+// src/hermes/link-skill.ts
+import { readFile as readFile14, stat as stat14 } from "fs/promises";
+import os4 from "os";
 import path21 from "path";
 import YAML3 from "yaml";
-var PROFILE_CREATE_LOG_FILE = "profile-create.log";
-var PROFILE_CREATE_LOG_MAX_FILES = 3;
-var MAX_PROFILE_CREATE_LOG_LINES = 260;
-var MAX_OUTPUT_LINE_LENGTH = 1200;
-var PROFILE_NAME_PATTERN5 = /^[a-z0-9][a-z0-9_-]{0,63}$/u;
-var ALL_COPY_SCOPES = [
-  "models",
-  "skills",
-  "tool_permissions",
-  "approval_policy"
-];
-var PROFILE_CREATION_EVENTS = new EventEmitter2();
-var runningProfileCreation = null;
-async function startHermesProfileCreation(input, options) {
-  const current = await readHermesProfileCreationStatus(options.paths);
-  if (runningProfileCreation || current.state === "running") {
-    return current;
+var HERMES_LINK_SKILL_ROOT_DIR = "hermes-skills";
+var HERMES_LINK_SKILL_DIR = "hermes-link";
+var HERMES_LINK_SKILL_FILE = "SKILL.md";
+var HERMES_LINK_SKILL_CONTENT = `---
+name: hermes-link
+description: Understand and troubleshoot Hermes Link, the local companion service that connects Hermes Agent to the HermesPilot mobile app.
+---
+
+# Hermes Link
+
+Hermes Link is a secure local companion service for hermes-agent. It lets the HermesPilot mobile app connect to the user's local Hermes Agent safely and reliably.
+
+Hermes Link is specifically for HermesPilot. It is not OpenClaw, ClawPilot, clawlink, or any OpenClaw companion service. Do not confuse those systems when helping the user.
+
+## What Hermes Link Does
+
+Hermes Link can:
+
+- pair the HermesPilot mobile app with this computer
+- expose a controlled local API for the app
+- connect through LAN, public direct routes, or Hermes Relay
+- help the app access Hermes profiles, conversations, messages, files, voice input, logs, and status
+- start or check the Hermes Gateway when needed
+
+Hermes Link does not replace Hermes Agent. Hermes Agent remains the actual AI agent runtime.
+
+## When To Use This Skill
+
+Use this skill when the user asks about:
+
+- HermesPilot App cannot connect
+- Link appears offline
+- pairing or QR code problems
+- mobile access to local Hermes
+- Relay, LAN, or public direct route problems
+- Hermes Link logs, daemon status, or diagnostics
+
+## Useful Commands
+
+Start with:
+
+\`\`\`bash
+hermeslink status
+hermeslink doctor
+\`\`\`
+
+For logs:
+
+\`\`\`bash
+hermeslink logs --error -n 50
+hermeslink logs --warn -n 100
+hermeslink logs -f
+hermeslink logs --all --level debug -f
+\`\`\`
+
+If the daemon appears stuck, suggest:
+
+\`\`\`bash
+hermeslink restart
+\`\`\`
+
+Explain that restarting Hermes Link may briefly disconnect the mobile app.
+
+## Troubleshooting Flow
+
+1. Check \`hermeslink status\`.
+2. Run \`hermeslink doctor\`.
+3. Inspect recent errors with \`hermeslink logs --error -n 50\`.
+4. If the issue is intermittent, reproduce it while running \`hermeslink logs -f\`.
+5. Check whether the phone and computer are on the same LAN, using Relay, or using a public direct route.
+6. If the user uses WSL, Docker, or a VM, verify that Hermes Agent and Hermes Link run in the same environment.
+
+## Safety
+
+Never reveal API keys, access tokens, refresh tokens, private keys, or full .env contents.
+
+Do not recommend exposing port 52379 directly to the public internet without TLS, VPN, Tailscale, WireGuard, or another access-control layer.
+
+Do not modify Hermes profiles, delete user data, edit config files, or kill processes unless the user explicitly asks.
+`;
+async function ensureHermesLinkSkillInstalledForProfiles(options = {}) {
+  const paths = options.paths ?? resolveRuntimePaths();
+  const externalDir = resolveHermesLinkSkillExternalDir(paths);
+  const skillPath = path21.join(
+    externalDir,
+    HERMES_LINK_SKILL_DIR,
+    HERMES_LINK_SKILL_FILE
+  );
+  const skillChanged = await writeHermesLinkSkill(skillPath);
+  const profiles = await listHermesProfiles(paths);
+  const results = [];
+  for (const profile of profiles) {
+    try {
+      results.push(await ensureProfileUsesExternalSkillDir(profile, externalDir));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({
+        profile: profile.name,
+        profilePath: profile.path,
+        configPath: profile.configPath,
+        changed: false,
+        backupPath: null,
+        skipped: false,
+        error: message
+      });
+    }
   }
-  const now = options.now ?? (() => /* @__PURE__ */ new Date());
-  const normalized = await normalizeProfileCreationInput(input, options.paths);
-  const profileName = normalized.name ?? await generateProfileName(normalized.displayName, options.paths);
-  const sourceProfile = normalized.copyFrom;
-  const copyScopes = normalized.copyScopes;
-  const jobId = `profile_create_${now().getTime().toString(36)}`;
-  await clearProfileCreationLogFiles(options.paths);
-  const writer = createRotatingTextLogWriter({
-    paths: options.paths,
-    fileName: PROFILE_CREATE_LOG_FILE,
-    maxFileBytes: 512 * 1024,
-    maxFiles: PROFILE_CREATE_LOG_MAX_FILES
-  });
-  const startedAt = now().toISOString();
-  const started = {
-    state: "running",
-    job_id: jobId,
-    profile_name: profileName,
-    source_profile: sourceProfile,
-    copied_scopes: [],
-    profile: null,
-    pid: null,
-    started_at: startedAt,
-    finished_at: null,
-    exit_code: null,
-    signal: null,
-    error: null
+  const changedProfiles = results.filter((result) => result.changed);
+  const failedProfiles = results.filter((result) => result.error);
+  if (skillChanged || changedProfiles.length > 0) {
+    void options.logger?.info("hermes_link_skill_ensured", {
+      source: options.source ?? "unspecified",
+      external_dir: externalDir,
+      skill_path: skillPath,
+      skill_changed: skillChanged,
+      changed_profiles: changedProfiles.map((result) => result.profile),
+      failed_profiles: failedProfiles.map((result) => result.profile)
+    });
+  }
+  if (failedProfiles.length > 0) {
+    void options.logger?.warn("hermes_link_skill_profile_ensure_failed", {
+      source: options.source ?? "unspecified",
+      profiles: failedProfiles.map((result) => ({
+        profile: result.profile,
+        error: result.error ?? "unknown error"
+      }))
+    });
+  }
+  return {
+    externalDir,
+    skillPath,
+    skillChanged,
+    profiles: results
   };
-  await mkdir11(options.paths.runDir, { recursive: true, mode: 448 });
-  await writeProfileCreationState(options.paths, started);
-  await writer.write(`
-=== profile creation started ${startedAt} ===
-`);
-  await writer.write(`Profile ID: ${profileName}
-`);
-  if (sourceProfile && copyScopes.length > 0) {
-    await writer.write(
-      `Copy from: ${sourceProfile} (${copyScopes.join(", ")})
-`
-    );
-  } else {
-    await writer.write("Copy from: none\n");
+}
+async function ensureHermesLinkSkillInstalledBestEffort(options = {}) {
+  try {
+    await ensureHermesLinkSkillInstalledForProfiles(options);
+  } catch (error) {
+    void options.logger?.warn("hermes_link_skill_ensure_failed", {
+      source: options.source ?? "unspecified",
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
-  const commandArgs = ["profile", "create", profileName, "--no-alias"];
-  await writer.write(`$ ${resolveHermesBin()} ${commandArgs.join(" ")}
-`);
-  await emitProfileCreationStatus(options.paths);
-  const child = spawn2(resolveHermesBin(), commandArgs, {
-    stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, HERMES_NONINTERACTIVE: "1" },
-    windowsHide: true,
-    detached: false
+}
+function resolveHermesLinkSkillExternalDir(paths = resolveRuntimePaths()) {
+  return path21.join(paths.homeDir, HERMES_LINK_SKILL_ROOT_DIR);
+}
+async function writeHermesLinkSkill(skillPath) {
+  const existing = await readFile14(skillPath, "utf8").catch((error) => {
+    if (isNodeError16(error, "ENOENT")) {
+      return null;
+    }
+    throw error;
   });
-  started.pid = child.pid ?? null;
-  await writeProfileCreationState(options.paths, started);
+  if (existing === HERMES_LINK_SKILL_CONTENT) {
+    return false;
+  }
+  await atomicWriteFilePreservingMetadata(skillPath, HERMES_LINK_SKILL_CONTENT);
+  return true;
+}
+async function ensureProfileUsesExternalSkillDir(profile, externalDir) {
+  const profilePath = resolveHermesProfileDir(profile.name);
+  const configPath = resolveHermesConfigPath(profile.name);
+  if (!await pathIsDirectory(profilePath)) {
+    return {
+      profile: profile.name,
+      profilePath,
+      configPath,
+      changed: false,
+      backupPath: null,
+      skipped: true
+    };
+  }
+  const { document, config, existingRaw } = await readHermesConfigDocument2(configPath);
+  const skillsConfig = ensureRecord2(config, "skills");
+  if (externalDirsInclude(skillsConfig.external_dirs, externalDir, profilePath)) {
+    return {
+      profile: profile.name,
+      profilePath,
+      configPath,
+      changed: false,
+      backupPath: null,
+      skipped: false
+    };
+  }
+  skillsConfig.external_dirs = appendExternalDir(
+    skillsConfig.external_dirs,
+    externalDir,
+    profilePath
+  );
+  const backupPath = await writeHermesConfigDocument2({
+    configPath,
+    document,
+    config,
+    existingRaw
+  });
+  return {
+    profile: profile.name,
+    profilePath,
+    configPath,
+    changed: true,
+    backupPath,
+    skipped: false
+  };
+}
+async function readHermesConfigDocument2(configPath) {
+  const existingRaw = await readFile14(configPath, "utf8").catch(
+    (error) => {
+      if (isNodeError16(error, "ENOENT")) {
+        return null;
+      }
+      throw error;
+    }
+  );
+  const document = existingRaw ? YAML3.parseDocument(existingRaw) : new YAML3.Document({});
+  return {
+    document,
+    config: toRecord15(document.toJSON()),
+    existingRaw
+  };
+}
+async function writeHermesConfigDocument2(input) {
+  const backupPath = input.existingRaw ? `${input.configPath}.bak.${Date.now()}` : null;
+  if (backupPath) {
+    await atomicWriteFilePreservingMetadata(backupPath, input.existingRaw, {
+      metadataSourcePath: input.configPath
+    });
+  }
+  input.document.contents = input.document.createNode(input.config);
+  await atomicWriteFilePreservingMetadata(
+    input.configPath,
+    input.document.toString()
+  );
+  return backupPath;
+}
+function appendExternalDir(current, externalDir, hermesHome) {
+  const entries = readExternalDirEntries(current);
+  const seen = new Set(
+    entries.map((entry) => resolveExternalDirEntry(entry, hermesHome))
+  );
+  const normalizedExternalDir = path21.resolve(externalDir);
+  return seen.has(normalizedExternalDir) ? entries : [...entries, normalizedExternalDir];
+}
+function externalDirsInclude(current, externalDir, hermesHome) {
+  const normalizedExternalDir = path21.resolve(externalDir);
+  return readExternalDirEntries(current).some(
+    (entry) => resolveExternalDirEntry(entry, hermesHome) === normalizedExternalDir
+  );
+}
+function readExternalDirEntries(value) {
+  const raw = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+  return raw.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
+}
+function resolveExternalDirEntry(entry, hermesHome) {
+  const expanded = expandHome(expandEnvVars(entry));
+  return path21.resolve(path21.isAbsolute(expanded) ? expanded : path21.join(hermesHome, expanded));
+}
+function expandHome(value) {
+  if (value === "~") {
+    return os4.homedir();
+  }
+  if (value.startsWith(`~${path21.sep}`) || value.startsWith("~/")) {
+    return path21.join(os4.homedir(), value.slice(2));
+  }
+  return value;
+}
+function expandEnvVars(value) {
+  return value.replace(
+    /\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)/gu,
+    (_match, braced, bare) => process.env[braced ?? bare ?? ""] ?? ""
+  );
+}
+async function pathIsDirectory(filePath) {
+  return stat14(filePath).then((value) => value.isDirectory()).catch((error) => {
+    if (isNodeError16(error, "ENOENT")) {
+      return false;
+    }
+    throw error;
+  });
+}
+function ensureRecord2(target, key) {
+  const existing = target[key];
+  if (isRecord3(existing)) {
+    return existing;
+  }
+  const next = {};
+  target[key] = next;
+  return next;
+}
+function toRecord15(value) {
+  return isRecord3(value) ? value : {};
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNodeError16(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+
+// src/hermes/profile-creation.ts
+var PROFILE_CREATE_LOG_FILE = "profile-create.log";
+var PROFILE_CREATE_LOG_MAX_FILES = 3;
+var MAX_PROFILE_CREATE_LOG_LINES = 260;
+var MAX_OUTPUT_LINE_LENGTH = 1200;
+var PROFILE_NAME_PATTERN5 = /^[a-z0-9][a-z0-9_-]{0,63}$/u;
+var ALL_COPY_SCOPES = [
+  "models",
+  "skills",
+  "tool_permissions",
+  "approval_policy"
+];
+var PROFILE_CREATION_EVENTS = new EventEmitter2();
+var runningProfileCreation = null;
+async function startHermesProfileCreation(input, options) {
+  const current = await readHermesProfileCreationStatus(options.paths);
+  if (runningProfileCreation || current.state === "running") {
+    return current;
+  }
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const normalized = await normalizeProfileCreationInput(input, options.paths);
+  const profileName = normalized.name ?? await generateProfileName(normalized.displayName, options.paths);
+  const sourceProfile = normalized.copyFrom;
+  const copyScopes = normalized.copyScopes;
+  const jobId = `profile_create_${now().getTime().toString(36)}`;
+  await clearProfileCreationLogFiles(options.paths);
+  const writer = createRotatingTextLogWriter({
+    paths: options.paths,
+    fileName: PROFILE_CREATE_LOG_FILE,
+    maxFileBytes: 512 * 1024,
+    maxFiles: PROFILE_CREATE_LOG_MAX_FILES
+  });
+  const startedAt = now().toISOString();
+  const started = {
+    state: "running",
+    job_id: jobId,
+    profile_name: profileName,
+    source_profile: sourceProfile,
+    copied_scopes: [],
+    profile: null,
+    pid: null,
+    started_at: startedAt,
+    finished_at: null,
+    exit_code: null,
+    signal: null,
+    error: null
+  };
+  await mkdir11(options.paths.runDir, { recursive: true, mode: 448 });
+  await writeProfileCreationState(options.paths, started);
+  await writer.write(`
+=== profile creation started ${startedAt} ===
+`);
+  await writer.write(`Profile ID: ${profileName}
+`);
+  if (sourceProfile && copyScopes.length > 0) {
+    await writer.write(
+      `Copy from: ${sourceProfile} (${copyScopes.join(", ")})
+`
+    );
+  } else {
+    await writer.write("Copy from: none\n");
+  }
+  const commandArgs = ["profile", "create", profileName, "--no-alias"];
+  await writer.write(`$ ${resolveHermesBin()} ${commandArgs.join(" ")}
+`);
+  await emitProfileCreationStatus(options.paths);
+  const child = spawn2(resolveHermesBin(), commandArgs, {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, HERMES_NONINTERACTIVE: "1" },
+    windowsHide: true,
+    detached: false
+  });
+  started.pid = child.pid ?? null;
+  await writeProfileCreationState(options.paths, started);
   await emitProfileCreationStatus(options.paths);
   const appendChunk = async (chunk) => {
     await writer.write(chunk);
@@ -20300,6 +21329,11 @@ async function applyProfileCreationPostSteps(input) {
   await input.writer.write("Ensuring Hermes API Server config...\n");
   await ensureHermesApiServerKey(input.profileName);
   await getHermesProfileStatus(input.profileName, input.paths);
+  await input.writer.write("Ensuring Hermes Link skill...\n");
+  await ensureHermesLinkSkillInstalledBestEffort({
+    paths: input.paths,
+    source: "profile_creation"
+  });
   if (input.displayName || input.description || input.avatarType === "url" || input.avatarUrl) {
     await input.writer.write("Saving Profile display metadata...\n");
     await updateProfileMetadata(input.paths, {
@@ -20352,23 +21386,23 @@ function copyModelConfig(source, target) {
       copied[key] = cloneJson(source[key]);
     }
   }
-  const sourceAuxiliary = toRecord15(source.auxiliary);
+  const sourceAuxiliary = toRecord16(source.auxiliary);
   if (Object.prototype.hasOwnProperty.call(sourceAuxiliary, "compression")) {
-    const targetAuxiliary = ensureRecord2(target, "auxiliary");
+    const targetAuxiliary = ensureRecord3(target, "auxiliary");
     targetAuxiliary.compression = cloneJson(sourceAuxiliary.compression);
     copied.auxiliary = { compression: cloneJson(sourceAuxiliary.compression) };
   }
   return copied;
 }
 function copyToolPermissionsConfig(source, target) {
-  const sourcePlatformToolsets = toRecord15(source.platform_toolsets);
+  const sourcePlatformToolsets = toRecord16(source.platform_toolsets);
   if (Object.prototype.hasOwnProperty.call(sourcePlatformToolsets, "api_server")) {
-    const targetPlatformToolsets = ensureRecord2(target, "platform_toolsets");
+    const targetPlatformToolsets = ensureRecord3(target, "platform_toolsets");
     targetPlatformToolsets.api_server = cloneJson(sourcePlatformToolsets.api_server);
   }
-  const sourceStt = toRecord15(source.stt);
+  const sourceStt = toRecord16(source.stt);
   if (Object.prototype.hasOwnProperty.call(sourceStt, "enabled")) {
-    const targetStt = ensureRecord2(target, "stt");
+    const targetStt = ensureRecord3(target, "stt");
     targetStt.enabled = cloneJson(sourceStt.enabled);
   }
   copyProperty(source, target, "command_allowlist");
@@ -20413,9 +21447,9 @@ function collectEnvKeys(value, keys = /* @__PURE__ */ new Set()) {
   return keys;
 }
 async function writeEnvValues(profileName, values) {
-  const envPath = path21.join(resolveHermesProfileDir(profileName), ".env");
-  const existingRaw = await readFile14(envPath, "utf8").catch((error) => {
-    if (isNodeError16(error, "ENOENT")) {
+  const envPath = path22.join(resolveHermesProfileDir(profileName), ".env");
+  const existingRaw = await readFile15(envPath, "utf8").catch((error) => {
+    if (isNodeError17(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -20450,8 +21484,8 @@ async function writeEnvValues(profileName, values) {
   await atomicWriteFilePreservingMetadata(envPath, nextRaw);
 }
 async function copySkills(sourceProfile, targetProfile) {
-  const sourceSkills = path21.join(resolveHermesProfileDir(sourceProfile), "skills");
-  const targetSkills = path21.join(resolveHermesProfileDir(targetProfile), "skills");
+  const sourceSkills = path22.join(resolveHermesProfileDir(sourceProfile), "skills");
+  const targetSkills = path22.join(resolveHermesProfileDir(targetProfile), "skills");
   if (!await pathExists2(sourceSkills)) {
     return;
   }
@@ -20474,16 +21508,16 @@ function copyProperty(source, target, key) {
   }
 }
 async function readYamlConfig(configPath) {
-  const existingRaw = await readFile14(configPath, "utf8").catch(
+  const existingRaw = await readFile15(configPath, "utf8").catch(
     (error) => {
-      if (isNodeError16(error, "ENOENT")) {
+      if (isNodeError17(error, "ENOENT")) {
         return null;
       }
       throw error;
     }
   );
   return {
-    config: toRecord15(existingRaw ? YAML3.parse(existingRaw) : {}),
+    config: toRecord16(existingRaw ? YAML4.parse(existingRaw) : {}),
     existingRaw
   };
 }
@@ -20495,7 +21529,7 @@ async function writeYamlConfig(configPath, input) {
       { metadataSourcePath: configPath }
     );
   }
-  const document = new YAML3.Document(input.config);
+  const document = new YAML4.Document(input.config);
   await atomicWriteFilePreservingMetadata(configPath, document.toString());
 }
 async function failProfileCreation(input) {
@@ -20537,7 +21571,7 @@ async function writeProfileCreationState(paths, state) {
   await writeJsonFile(profileCreationStatePath(paths), state);
 }
 async function readProfileCreationLogLines(paths) {
-  const raw = await readFile14(profileCreationLogPath(paths), "utf8").catch(() => "");
+  const raw = await readFile15(profileCreationLogPath(paths), "utf8").catch(() => "");
   if (!raw.trim()) {
     return [];
   }
@@ -20546,10 +21580,10 @@ async function readProfileCreationLogLines(paths) {
   );
 }
 function profileCreationStatePath(paths) {
-  return path21.join(paths.runDir, "profile-create-state.json");
+  return path22.join(paths.runDir, "profile-create-state.json");
 }
 function profileCreationLogPath(paths) {
-  return path21.join(paths.logsDir, PROFILE_CREATE_LOG_FILE);
+  return path22.join(paths.logsDir, PROFILE_CREATE_LOG_FILE);
 }
 async function clearProfileCreationLogFiles(paths) {
   const primary = profileCreationLogPath(paths);
@@ -20562,8 +21596,8 @@ async function clearProfileCreationLogFiles(paths) {
   ]);
 }
 async function pathExists2(targetPath) {
-  return await stat14(targetPath).then(() => true).catch((error) => {
-    if (isNodeError16(error, "ENOENT")) {
+  return await stat15(targetPath).then(() => true).catch((error) => {
+    if (isNodeError17(error, "ENOENT")) {
       return false;
     }
     throw error;
@@ -20586,7 +21620,7 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-function ensureRecord2(target, key) {
+function ensureRecord3(target, key) {
   const value = target[key];
   if (typeof value === "object" && value !== null && !Array.isArray(value)) {
     return value;
@@ -20595,7 +21629,7 @@ function ensureRecord2(target, key) {
   target[key] = next;
   return next;
 }
-function toRecord15(value) {
+function toRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 function cloneJson(value) {
@@ -20610,7 +21644,7 @@ function formatEnvValue2(value) {
 function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
-function isNodeError16(error, code) {
+function isNodeError17(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 
@@ -20820,11 +21854,11 @@ function toProfileToolConfigHttpError(error) {
 import {
   access as access3,
   readdir as readdir10,
-  readFile as readFile15,
-  stat as stat15
+  readFile as readFile16,
+  stat as stat16
 } from "fs/promises";
-import path22 from "path";
-import YAML4 from "yaml";
+import path23 from "path";
+import YAML5 from "yaml";
 var ENTRY_DELIMITER = "\n\xA7\n";
 var DEFAULT_MEMORY_LIMIT = 2200;
 var DEFAULT_USER_LIMIT = 1375;
@@ -21145,7 +22179,7 @@ async function saveProviderSettings(profileName, provider, patch) {
     });
     await patchJsonProviderConfig(
       profileName,
-      path22.join("hindsight", "config.json"),
+      path23.join("hindsight", "config.json"),
       {
         mode: patch.mode,
         api_url: patch.apiUrl,
@@ -21202,7 +22236,7 @@ async function patchCustomProviderConfig(profileName, provider, patch) {
       "\u81EA\u5B9A\u4E49 memory provider \u914D\u7F6E\u5FC5\u987B\u662F\u6709\u6548\u7684 JSON object\u3002"
     );
   }
-  const config = toRecord16(parsed);
+  const config = toRecord17(parsed);
   if (Object.keys(config).length === 0 && parsed !== null) {
     throw new HermesMemoryError(
       "memory_provider_config_invalid",
@@ -21293,17 +22327,17 @@ function normalizeCustomProviderId(provider) {
 }
 async function patchHermesMemoryProvider(profileName, provider) {
   const configPath = resolveHermesConfigPath(profileName);
-  const existingRaw = await readFile15(configPath, "utf8").catch(
+  const existingRaw = await readFile16(configPath, "utf8").catch(
     (error) => {
-      if (isNodeError17(error, "ENOENT")) {
+      if (isNodeError18(error, "ENOENT")) {
         return null;
       }
       throw error;
     }
   );
-  const document = existingRaw ? YAML4.parseDocument(existingRaw) : new YAML4.Document({});
-  const config = toRecord16(document.toJSON());
-  const memory = toRecord16(config.memory);
+  const document = existingRaw ? YAML5.parseDocument(existingRaw) : new YAML5.Document({});
+  const config = toRecord17(document.toJSON());
+  const memory = toRecord17(config.memory);
   memory.provider = provider === "built-in" ? "" : provider;
   config.memory = memory;
   const backupPath = existingRaw ? `${configPath}.bak.${Date.now()}` : null;
@@ -21316,13 +22350,13 @@ async function patchHermesMemoryProvider(profileName, provider) {
   await atomicWriteFilePreservingMetadata(configPath, document.toString());
 }
 function resolveMemoryDir(profileName) {
-  return path22.join(resolveHermesProfileDir(profileName), "memories");
+  return path23.join(resolveHermesProfileDir(profileName), "memories");
 }
 async function readMemoryStore(profileName, target, limits) {
   const filePath = memoryFilePath(profileName, target);
   const entries = await readMemoryEntries(filePath);
-  const fileStat = await stat15(filePath).catch((error) => {
-    if (isNodeError17(error, "ENOENT")) {
+  const fileStat = await stat16(filePath).catch((error) => {
+    if (isNodeError18(error, "ENOENT")) {
       return null;
     }
     throw error;
@@ -21350,8 +22384,8 @@ async function readMemoryStore(profileName, target, limits) {
   };
 }
 async function readMemoryEntries(filePath) {
-  const raw = await readFile15(filePath, "utf8").catch((error) => {
-    if (isNodeError17(error, "ENOENT")) {
+  const raw = await readFile16(filePath, "utf8").catch((error) => {
+    if (isNodeError18(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -21377,7 +22411,7 @@ async function writeMemoryEntries(profileName, target, entries) {
   );
 }
 function memoryFilePath(profileName, target) {
-  return path22.join(
+  return path23.join(
     resolveMemoryDir(profileName),
     target === "user" ? "USER.md" : "MEMORY.md"
   );
@@ -21410,7 +22444,7 @@ async function readCustomProviderSummaries(profileName, activeProviderId) {
   }
   return Promise.all(
     [...descriptors.values()].map(async (descriptor) => {
-      const installed = await isUserMemoryProviderInstalled(
+      const installed2 = await isUserMemoryProviderInstalled(
         profileName,
         descriptor.id
       );
@@ -21420,8 +22454,8 @@ async function readCustomProviderSummaries(profileName, activeProviderId) {
         description: descriptor.description,
         active: descriptor.id === activeProviderId,
         configurable: true,
-        configured: installed,
-        configurationIssue: installed ? null : "\u6CA1\u6709\u5728\u5F53\u524D HERMES_HOME/plugins/ \u4E0B\u53D1\u73B0\u8FD9\u4E2A\u81EA\u5B9A\u4E49 memory provider\u3002",
+        configured: installed2,
+        configurationIssue: installed2 ? null : "\u6CA1\u6709\u5728\u5F53\u524D HERMES_HOME/plugins/ \u4E0B\u53D1\u73B0\u8FD9\u4E2A\u81EA\u5B9A\u4E49 memory provider\u3002",
         providerConfigPath: customProviderConfigPath(profileName, descriptor.id),
         settings: await readCustomProviderSettings(profileName, descriptor.id)
       };
@@ -21437,7 +22471,7 @@ async function readCustomProviderSetupSummary(profileName) {
     configurable: true,
     configured: true,
     configurationIssue: null,
-    providerConfigPath: path22.join(
+    providerConfigPath: path23.join(
       resolveHermesProfileDir(profileName),
       "<provider>.json"
     ),
@@ -21766,8 +22800,8 @@ async function readProviderSettings(profileName, provider) {
       memoryProviderConfigPath(profileName, provider) ?? ""
     );
     const env = await readHermesMemoryEnv(profileName);
-    const banks = toRecord16(config.banks);
-    const hermesBank = toRecord16(banks.hermes);
+    const banks = toRecord17(config.banks);
+    const hermesBank = toRecord17(banks.hermes);
     const mode = normalizeHindsightMode(config.mode);
     return [
       selectSetting("mode", "\u8FDE\u63A5\u6A21\u5F0F", mode, [
@@ -21831,7 +22865,7 @@ async function readProviderSettings(profileName, provider) {
       stringSetting(
         "dbPath",
         "SQLite \u6570\u636E\u5E93\u8DEF\u5F84",
-        config.db_path ?? path22.join(resolveHermesProfileDir(profileName), "memory_store.db")
+        config.db_path ?? path23.join(resolveHermesProfileDir(profileName), "memory_store.db")
       ),
       booleanSetting("autoExtract", "\u4F1A\u8BDD\u7ED3\u675F\u81EA\u52A8\u62BD\u53D6", config.auto_extract ?? false),
       numberSetting("defaultTrust", "\u9ED8\u8BA4\u4FE1\u4EFB\u5206", config.default_trust ?? 0.5),
@@ -21867,7 +22901,7 @@ async function readProviderSettings(profileName, provider) {
       stringSetting(
         "workingDirectory",
         "\u5DE5\u4F5C\u76EE\u5F55",
-        path22.join(resolveHermesProfileDir(profileName), "byterover"),
+        path23.join(resolveHermesProfileDir(profileName), "byterover"),
         false
       )
     ];
@@ -21876,16 +22910,16 @@ async function readProviderSettings(profileName, provider) {
 }
 function memoryProviderConfigPath(profileName, provider) {
   if (provider === "honcho") {
-    return path22.join(resolveHermesProfileDir(profileName), "honcho.json");
+    return path23.join(resolveHermesProfileDir(profileName), "honcho.json");
   }
   if (provider === "mem0") {
-    return path22.join(resolveHermesProfileDir(profileName), "mem0.json");
+    return path23.join(resolveHermesProfileDir(profileName), "mem0.json");
   }
   if (provider === "supermemory") {
-    return path22.join(resolveHermesProfileDir(profileName), "supermemory.json");
+    return path23.join(resolveHermesProfileDir(profileName), "supermemory.json");
   }
   if (provider === "hindsight") {
-    return path22.join(
+    return path23.join(
       resolveHermesProfileDir(profileName),
       "hindsight",
       "config.json"
@@ -21894,21 +22928,21 @@ function memoryProviderConfigPath(profileName, provider) {
   return null;
 }
 function customProviderConfigPath(profileName, provider) {
-  return path22.join(
+  return path23.join(
     resolveHermesProfileDir(profileName),
     `${normalizeCustomProviderId(provider)}.json`
   );
 }
 function customProviderRegistryPath(profileName) {
-  return path22.join(
+  return path23.join(
     resolveHermesProfileDir(profileName),
     CUSTOM_PROVIDER_REGISTRY_FILE
   );
 }
 async function readCustomProviderRegistry(profileName) {
-  const raw = await readFile15(customProviderRegistryPath(profileName), "utf8").catch(
+  const raw = await readFile16(customProviderRegistryPath(profileName), "utf8").catch(
     (error) => {
-      if (isNodeError17(error, "ENOENT")) {
+      if (isNodeError18(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -21919,13 +22953,13 @@ async function readCustomProviderRegistry(profileName) {
   }
   try {
     const parsed = JSON.parse(raw);
-    const providers = Array.isArray(parsed) ? parsed : Array.isArray(toRecord16(parsed).providers) ? toRecord16(parsed).providers : [];
+    const providers = Array.isArray(parsed) ? parsed : Array.isArray(toRecord17(parsed).providers) ? toRecord17(parsed).providers : [];
     return providers.map((item) => {
       if (typeof item === "string") {
         const id2 = normalizeCustomProviderId(item);
         return { id: id2, label: id2, description: "\u81EA\u5B9A\u4E49 memory provider\u3002" };
       }
-      const record = toRecord16(item);
+      const record = toRecord17(item);
       const id = normalizeCustomProviderId(readString17(record.id) ?? "");
       return {
         id,
@@ -21952,10 +22986,10 @@ async function saveCustomProviderRegistryEntry(profileName, provider) {
   );
 }
 async function discoverUserMemoryProviderDescriptors(profileName) {
-  const pluginsDir = path22.join(resolveHermesProfileDir(profileName), "plugins");
+  const pluginsDir = path23.join(resolveHermesProfileDir(profileName), "plugins");
   const entries = await readdir10(pluginsDir, { withFileTypes: true }).catch(
     (error) => {
-      if (isNodeError17(error, "ENOENT")) {
+      if (isNodeError18(error, "ENOENT")) {
         return [];
       }
       throw error;
@@ -21972,7 +23006,7 @@ async function discoverUserMemoryProviderDescriptors(profileName) {
     } catch {
       continue;
     }
-    const providerDir = path22.join(pluginsDir, entry.name);
+    const providerDir = path23.join(pluginsDir, entry.name);
     if (!await isMemoryProviderPluginDir(providerDir)) {
       continue;
     }
@@ -21986,7 +23020,7 @@ async function discoverUserMemoryProviderDescriptors(profileName) {
   return descriptors;
 }
 async function isUserMemoryProviderInstalled(profileName, provider) {
-  const providerDir = path22.join(
+  const providerDir = path23.join(
     resolveHermesProfileDir(profileName),
     "plugins",
     normalizeCustomProviderId(provider)
@@ -21994,9 +23028,9 @@ async function isUserMemoryProviderInstalled(profileName, provider) {
   return isMemoryProviderPluginDir(providerDir);
 }
 async function isMemoryProviderPluginDir(providerDir) {
-  const source = await readFile15(path22.join(providerDir, "__init__.py"), "utf8").catch(
+  const source = await readFile16(path23.join(providerDir, "__init__.py"), "utf8").catch(
     (error) => {
-      if (isNodeError17(error, "ENOENT")) {
+      if (isNodeError18(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -22006,22 +23040,22 @@ async function isMemoryProviderPluginDir(providerDir) {
   return sample.includes("register_memory_provider") || sample.includes("MemoryProvider");
 }
 async function readPluginMetadata(providerDir) {
-  const raw = await readFile15(path22.join(providerDir, "plugin.yaml"), "utf8").catch(
+  const raw = await readFile16(path23.join(providerDir, "plugin.yaml"), "utf8").catch(
     (error) => {
-      if (isNodeError17(error, "ENOENT")) {
+      if (isNodeError18(error, "ENOENT")) {
         return "";
       }
       throw error;
     }
   );
-  return raw ? toRecord16(YAML4.parse(raw)) : {};
+  return raw ? toRecord17(YAML5.parse(raw)) : {};
 }
 async function resolveByteRoverCli() {
   const candidates = [
-    ...(process.env.PATH ?? "").split(path22.delimiter).filter(Boolean).map((dir) => path22.join(dir, "brv")),
-    path22.join(process.env.HOME ?? "", ".brv-cli", "bin", "brv"),
+    ...(process.env.PATH ?? "").split(path23.delimiter).filter(Boolean).map((dir) => path23.join(dir, "brv")),
+    path23.join(process.env.HOME ?? "", ".brv-cli", "bin", "brv"),
     "/usr/local/bin/brv",
-    path22.join(process.env.HOME ?? "", ".npm-global", "bin", "brv")
+    path23.join(process.env.HOME ?? "", ".npm-global", "bin", "brv")
   ].filter(Boolean);
   for (const candidate of candidates) {
     const found = await access3(candidate).then(() => true).catch(() => false);
@@ -22032,32 +23066,32 @@ async function resolveByteRoverCli() {
   return null;
 }
 async function readHolographicProviderConfig(profileName) {
-  const raw = await readFile15(resolveHermesConfigPath(profileName), "utf8").catch(
+  const raw = await readFile16(resolveHermesConfigPath(profileName), "utf8").catch(
     (error) => {
-      if (isNodeError17(error, "ENOENT")) {
+      if (isNodeError18(error, "ENOENT")) {
         return "";
       }
       throw error;
     }
   );
-  const config = raw ? toRecord16(YAML4.parse(raw)) : {};
-  const plugins = toRecord16(config.plugins);
-  return toRecord16(plugins["hermes-memory-store"]);
+  const config = raw ? toRecord17(YAML5.parse(raw)) : {};
+  const plugins = toRecord17(config.plugins);
+  return toRecord17(plugins["hermes-memory-store"]);
 }
 async function patchHolographicProviderConfig(profileName, patch) {
   const configPath = resolveHermesConfigPath(profileName);
-  const existingRaw = await readFile15(configPath, "utf8").catch(
+  const existingRaw = await readFile16(configPath, "utf8").catch(
     (error) => {
-      if (isNodeError17(error, "ENOENT")) {
+      if (isNodeError18(error, "ENOENT")) {
         return null;
       }
       throw error;
     }
   );
-  const document = existingRaw ? YAML4.parseDocument(existingRaw) : new YAML4.Document({});
-  const config = toRecord16(document.toJSON());
-  const plugins = toRecord16(config.plugins);
-  const memoryStore = toRecord16(plugins["hermes-memory-store"]);
+  const document = existingRaw ? YAML5.parseDocument(existingRaw) : new YAML5.Document({});
+  const config = toRecord17(document.toJSON());
+  const plugins = toRecord17(config.plugins);
+  const memoryStore = toRecord17(plugins["hermes-memory-store"]);
   for (const [key, value] of Object.entries(patch)) {
     if (value !== void 0) {
       memoryStore[key] = value;
@@ -22082,9 +23116,9 @@ async function patchHermesMemoryEnv(profileName, patch) {
   if (entries.length === 0) {
     return;
   }
-  const envPath = path22.join(resolveHermesProfileDir(profileName), ".env");
-  const existingRaw = await readFile15(envPath, "utf8").catch((error) => {
-    if (isNodeError17(error, "ENOENT")) {
+  const envPath = path23.join(resolveHermesProfileDir(profileName), ".env");
+  const existingRaw = await readFile16(envPath, "utf8").catch((error) => {
+    if (isNodeError18(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -22205,7 +23239,7 @@ function joinHindsightUrl(baseUrl, pathName) {
 }
 function parseJsonObject2(text) {
   try {
-    return toRecord16(JSON.parse(text));
+    return toRecord17(JSON.parse(text));
   } catch {
     return {};
   }
@@ -22235,17 +23269,17 @@ function summarizeHindsightProbe(pathName, json) {
   return bankId ? `bank ${bankId} reachable` : "bank config reachable";
 }
 async function readActiveMemoryProvider(profileName) {
-  const raw = await readFile15(
+  const raw = await readFile16(
     resolveHermesConfigPath(profileName),
     "utf8"
   ).catch((error) => {
-    if (isNodeError17(error, "ENOENT")) {
+    if (isNodeError18(error, "ENOENT")) {
       return "";
     }
     throw error;
   });
-  const config = raw ? toRecord16(YAML4.parse(raw)) : {};
-  const memory = toRecord16(config.memory);
+  const config = raw ? toRecord17(YAML5.parse(raw)) : {};
+  const memory = toRecord17(config.memory);
   const provider = readString17(memory.provider);
   if (!provider || provider === "built-in" || provider === "builtin" || provider === "built_in") {
     return null;
@@ -22253,7 +23287,7 @@ async function readActiveMemoryProvider(profileName) {
   return provider;
 }
 async function patchJsonProviderConfig(profileName, relativePath, patch) {
-  const configPath = path22.join(
+  const configPath = path23.join(
     resolveHermesProfileDir(profileName),
     relativePath
   );
@@ -22271,18 +23305,18 @@ async function patchJsonProviderConfig(profileName, relativePath, patch) {
   );
 }
 async function readJsonObject(filePath) {
-  const raw = await readFile15(filePath, "utf8").catch((error) => {
-    if (isNodeError17(error, "ENOENT")) {
+  const raw = await readFile16(filePath, "utf8").catch((error) => {
+    if (isNodeError18(error, "ENOENT")) {
       return "{}";
     }
     throw error;
   });
   try {
-    return toRecord16(JSON.parse(raw || "{}"));
+    return toRecord17(JSON.parse(raw || "{}"));
   } catch {
     throw new HermesMemoryError(
       "memory_provider_config_invalid",
-      `${path22.basename(filePath)} \u4E0D\u662F\u6709\u6548\u7684 JSON \u914D\u7F6E\u6587\u4EF6\u3002`
+      `${path23.basename(filePath)} \u4E0D\u662F\u6709\u6548\u7684 JSON \u914D\u7F6E\u6587\u4EF6\u3002`
     );
   }
 }
@@ -22332,17 +23366,17 @@ function selectSetting(key, label, value, options, editable = true) {
   return { key, label, value: stringValue, editable, kind: "select", options };
 }
 async function readMemoryLimits(profileName) {
-  const raw = await readFile15(
+  const raw = await readFile16(
     resolveHermesConfigPath(profileName),
     "utf8"
   ).catch((error) => {
-    if (isNodeError17(error, "ENOENT")) {
+    if (isNodeError18(error, "ENOENT")) {
       return "";
     }
     throw error;
   });
-  const config = raw ? toRecord16(YAML4.parse(raw)) : {};
-  const memory = toRecord16(config.memory);
+  const config = raw ? toRecord17(YAML5.parse(raw)) : {};
+  const memory = toRecord17(config.memory);
   return {
     memory: readPositiveInteger3(memory.memory_char_limit) ?? DEFAULT_MEMORY_LIMIT,
     user: readPositiveInteger3(memory.user_char_limit) ?? DEFAULT_USER_LIMIT
@@ -22398,7 +23432,7 @@ function hashString(value) {
   }
   return hash.toString(16);
 }
-function toRecord16(value) {
+function toRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 function readString17(value) {
@@ -22429,7 +23463,7 @@ function formatEnvValue3(value) {
 function escapeRegExp4(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
-function isNodeError17(error, code) {
+function isNodeError18(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
 
@@ -22870,9 +23904,9 @@ function toMemoryHttpError(error) {
 }
 
 // src/hermes/skills.ts
-import { readFile as readFile16, readdir as readdir11 } from "fs/promises";
-import path23 from "path";
-import YAML5 from "yaml";
+import { readFile as readFile17, readdir as readdir11 } from "fs/promises";
+import path24 from "path";
+import YAML6 from "yaml";
 var HermesSkillNotFoundError = class extends Error {
   constructor(skillName) {
     super(`skill "${skillName}" does not exist`);
@@ -22885,7 +23919,7 @@ var EXCLUDED_SKILL_DIRS = /* @__PURE__ */ new Set([".git", ".github", ".hub"]);
 async function listHermesProfileSkills(profileName, paths = resolveRuntimePaths()) {
   const profile = await readExistingProfile(profileName, paths);
   const profileDir = resolveHermesProfileDir(profile.name);
-  const skillsRoot = path23.join(profileDir, "skills");
+  const skillsRoot = path24.join(profileDir, "skills");
   const [skillFiles, disabled, provenance] = await Promise.all([
     findSkillFiles(skillsRoot),
     readDisabledSkillNames(resolveHermesConfigPath(profile.name)),
@@ -22921,8 +23955,8 @@ async function setHermesProfileSkillEnabled(profileName, skillName, enabled, pat
     throw new HermesSkillNotFoundError(skillName);
   }
   const configPath = resolveHermesConfigPath(current.profile.name);
-  const { document, config, existingRaw } = await readHermesConfigDocument2(configPath);
-  const skillsConfig = ensureRecord3(config, "skills");
+  const { document, config, existingRaw } = await readHermesConfigDocument3(configPath);
+  const skillsConfig = ensureRecord4(config, "skills");
   const disabled = new Set(readStringList3(skillsConfig.disabled));
   if (enabled) {
     disabled.delete(target.name);
@@ -22932,7 +23966,7 @@ async function setHermesProfileSkillEnabled(profileName, skillName, enabled, pat
   skillsConfig.disabled = [...disabled].sort(
     (left, right) => left.localeCompare(right)
   );
-  const backupPath = await writeHermesConfigDocument2({
+  const backupPath = await writeHermesConfigDocument3({
     configPath,
     document,
     config,
@@ -22964,7 +23998,7 @@ async function findSkillFiles(root) {
 async function collectSkillFiles(directory, results) {
   const entries = await readdir11(directory, { withFileTypes: true }).catch(
     (error) => {
-      if (isNodeError18(error, "ENOENT")) {
+      if (isNodeError19(error, "ENOENT")) {
         return [];
       }
       throw error;
@@ -22976,7 +24010,7 @@ async function collectSkillFiles(directory, results) {
     if (EXCLUDED_SKILL_DIRS.has(entry.name)) {
       continue;
     }
-    const entryPath = path23.join(directory, entry.name);
+    const entryPath = path24.join(directory, entry.name);
     if (entry.isDirectory()) {
       await collectSkillFiles(entryPath, results);
       continue;
@@ -22987,9 +24021,9 @@ async function collectSkillFiles(directory, results) {
   }
 }
 async function readSkillMetadata(input) {
-  const raw = await readFile16(input.skillFile, "utf8").catch(
+  const raw = await readFile17(input.skillFile, "utf8").catch(
     (error) => {
-      if (isNodeError18(error, "ENOENT") || isNodeError18(error, "EACCES")) {
+      if (isNodeError19(error, "ENOENT") || isNodeError19(error, "EACCES")) {
         return null;
       }
       throw error;
@@ -22998,10 +24032,10 @@ async function readSkillMetadata(input) {
   if (raw === null) {
     return null;
   }
-  const skillDir = path23.dirname(input.skillFile);
+  const skillDir = path24.dirname(input.skillFile);
   const { frontmatter, body } = parseSkillDocument(raw.slice(0, 4e3));
   const name = normalizeSkillName(
-    readString18(frontmatter.name) ?? path23.basename(skillDir)
+    readString18(frontmatter.name) ?? path24.basename(skillDir)
   );
   if (!name) {
     return null;
@@ -23020,7 +24054,7 @@ async function readSkillMetadata(input) {
     enabled: !input.disabled.has(name),
     source: provenance.source,
     trust: provenance.trust,
-    relativePath: path23.relative(input.skillsRoot, skillDir)
+    relativePath: path24.relative(input.skillsRoot, skillDir)
   };
 }
 function parseSkillDocument(raw) {
@@ -23033,7 +24067,7 @@ function parseSkillDocument(raw) {
   }
   try {
     return {
-      frontmatter: toRecord17(YAML5.parse(match[1] ?? "")),
+      frontmatter: toRecord18(YAML6.parse(match[1] ?? "")),
       body: content.slice(match[0].length)
     };
   } catch {
@@ -23041,8 +24075,8 @@ function parseSkillDocument(raw) {
   }
 }
 function categoryFromPath(skillsRoot, skillFile) {
-  const relative = path23.relative(skillsRoot, skillFile);
-  const parts = relative.split(path23.sep).filter(Boolean);
+  const relative = path24.relative(skillsRoot, skillFile);
+  const parts = relative.split(path24.sep).filter(Boolean);
   return parts.length >= 3 ? parts[0] : null;
 }
 function firstBodyDescription(body) {
@@ -23065,8 +24099,8 @@ function normalizeDescription(value) {
   return `${description.slice(0, MAX_DESCRIPTION_LENGTH - 3)}...`;
 }
 async function readDisabledSkillNames(configPath) {
-  const raw = await readFile16(configPath, "utf8").catch((error) => {
-    if (isNodeError18(error, "ENOENT")) {
+  const raw = await readFile17(configPath, "utf8").catch((error) => {
+    if (isNodeError19(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -23074,8 +24108,8 @@ async function readDisabledSkillNames(configPath) {
   if (!raw.trim()) {
     return /* @__PURE__ */ new Set();
   }
-  const config = toRecord17(YAML5.parse(raw));
-  const skills = toRecord17(config.skills);
+  const config = toRecord18(YAML6.parse(raw));
+  const skills = toRecord18(config.skills);
   return new Set(readStringList3(skills.disabled));
 }
 async function readSkillProvenance(root) {
@@ -23089,9 +24123,9 @@ async function readSkillProvenance(root) {
   return provenance;
 }
 async function readBundledSkillNames(root) {
-  const raw = await readFile16(path23.join(root, ".bundled_manifest"), "utf8").catch(
+  const raw = await readFile17(path24.join(root, ".bundled_manifest"), "utf8").catch(
     (error) => {
-      if (isNodeError18(error, "ENOENT")) {
+      if (isNodeError19(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -23112,9 +24146,9 @@ async function readBundledSkillNames(root) {
   return names;
 }
 async function readHubInstalledSkills(root) {
-  const raw = await readFile16(path23.join(root, ".hub", "lock.json"), "utf8").catch(
+  const raw = await readFile17(path24.join(root, ".hub", "lock.json"), "utf8").catch(
     (error) => {
-      if (isNodeError18(error, "ENOENT")) {
+      if (isNodeError19(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -23125,14 +24159,14 @@ async function readHubInstalledSkills(root) {
   }
   let lock;
   try {
-    lock = toRecord17(JSON.parse(raw));
+    lock = toRecord18(JSON.parse(raw));
   } catch {
     return /* @__PURE__ */ new Map();
   }
-  const installed = toRecord17(lock.installed);
+  const installed2 = toRecord18(lock.installed);
   const result = /* @__PURE__ */ new Map();
-  for (const [name, rawEntry] of Object.entries(installed)) {
-    const entry = toRecord17(rawEntry);
+  for (const [name, rawEntry] of Object.entries(installed2)) {
+    const entry = toRecord18(rawEntry);
     result.set(normalizeSkillName(name), {
       source: readString18(entry.source) ?? "hub",
       trust: readString18(entry.trust_level) ?? null
@@ -23183,23 +24217,23 @@ function compareCategoryNames(left, right) {
   }
   return left.localeCompare(right);
 }
-async function readHermesConfigDocument2(configPath) {
-  const existingRaw = await readFile16(configPath, "utf8").catch(
+async function readHermesConfigDocument3(configPath) {
+  const existingRaw = await readFile17(configPath, "utf8").catch(
     (error) => {
-      if (isNodeError18(error, "ENOENT")) {
+      if (isNodeError19(error, "ENOENT")) {
         return null;
       }
       throw error;
     }
   );
-  const document = existingRaw ? YAML5.parseDocument(existingRaw) : new YAML5.Document({});
+  const document = existingRaw ? YAML6.parseDocument(existingRaw) : new YAML6.Document({});
   return {
     document,
-    config: toRecord17(document.toJSON()),
+    config: toRecord18(document.toJSON()),
     existingRaw
   };
 }
-async function writeHermesConfigDocument2(input) {
+async function writeHermesConfigDocument3(input) {
   const backupPath = input.existingRaw ? `${input.configPath}.bak.${Date.now()}` : null;
   if (backupPath) {
     await atomicWriteFilePreservingMetadata(backupPath, input.existingRaw, {
@@ -23222,18 +24256,18 @@ function readStringList3(value) {
 function readString18(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function toRecord17(value) {
+function toRecord18(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
-function ensureRecord3(target, key) {
-  const current = toRecord17(target[key]);
+function ensureRecord4(target, key) {
+  const current = toRecord18(target[key]);
   if (current === target[key]) {
     return current;
   }
   target[key] = current;
   return current;
 }
-function isNodeError18(error, code) {
+function isNodeError19(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 
@@ -23716,8 +24750,8 @@ function readModelList(payload) {
 // src/hermes/updates.ts
 import { EventEmitter as EventEmitter3 } from "events";
 import { spawn as spawn3 } from "child_process";
-import { mkdir as mkdir12, readFile as readFile17, rm as rm7 } from "fs/promises";
-import path24 from "path";
+import { mkdir as mkdir12, readFile as readFile18, rm as rm7 } from "fs/promises";
+import path25 from "path";
 var SERVER_HERMES_RELEASES_LATEST_PATH = "/api/v1/hermes-agent/releases/latest";
 var RELEASE_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
 var RELEASE_FETCH_TIMEOUT_MS = 5e3;
@@ -23950,7 +24984,7 @@ async function readRemoteRelease(options, now) {
   }
 }
 function normalizeServerReleaseSnapshot(payload) {
-  const snapshot = toRecord18(payload);
+  const snapshot = toRecord19(payload);
   const remote = toNullableRecord(snapshot.remote);
   return {
     remote: remote ? normalizeServerRelease(remote) : null,
@@ -23986,7 +25020,7 @@ async function writeUpdateState(paths, state) {
   await writeJsonFile(updateStatePath(paths), state);
 }
 async function readUpdateLogLines(paths) {
-  const raw = await readFile17(updateLogPath(paths), "utf8").catch(() => "");
+  const raw = await readFile18(updateLogPath(paths), "utf8").catch(() => "");
   if (!raw.trim()) {
     return [];
   }
@@ -23995,13 +25029,13 @@ async function readUpdateLogLines(paths) {
   );
 }
 function releaseCachePath(paths) {
-  return path24.join(paths.indexesDir, "hermes-release-check.json");
+  return path25.join(paths.indexesDir, "hermes-release-check.json");
 }
 function updateStatePath(paths) {
-  return path24.join(paths.runDir, "hermes-update-state.json");
+  return path25.join(paths.runDir, "hermes-update-state.json");
 }
 function updateLogPath(paths) {
-  return path24.join(paths.logsDir, UPDATE_LOG_FILE);
+  return path25.join(paths.logsDir, UPDATE_LOG_FILE);
 }
 async function clearUpdateLogFiles(paths) {
   const primary = updateLogPath(paths);
@@ -24039,7 +25073,7 @@ function compareSemver2(left, right) {
   }
   return 0;
 }
-function toRecord18(value) {
+function toRecord19(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function toNullableRecord(value) {
@@ -24101,13 +25135,13 @@ function readString19(payload, key) {
 // src/link/updates.ts
 import { spawn as spawn5 } from "child_process";
 import { EventEmitter as EventEmitter4 } from "events";
-import { mkdir as mkdir15, readFile as readFile19, rm as rm10 } from "fs/promises";
-import path26 from "path";
+import { mkdir as mkdir15, readFile as readFile20, rm as rm10 } from "fs/promises";
+import path27 from "path";
 
 // src/daemon/process.ts
 import { spawn as spawn4 } from "child_process";
-import { mkdir as mkdir14, readFile as readFile18, rm as rm9 } from "fs/promises";
-import path25 from "path";
+import { mkdir as mkdir14, readFile as readFile19, rm as rm9, writeFile as writeFile4 } from "fs/promises";
+import path26 from "path";
 
 // src/daemon/service.ts
 import { createServer } from "http";
@@ -24116,6 +25150,121 @@ import { mkdir as mkdir13, rm as rm8, writeFile as writeFile3 } from "fs/promise
 // src/relay/control-client.ts
 import WebSocket from "ws";
 
+// src/relay/reconnect-state.ts
+var DEFAULT_STORM_WINDOW_MS = 5 * 6e4;
+var DEFAULT_STORM_DISCONNECT_LIMIT = 8;
+var DEFAULT_COOLDOWN_MS = 3 * 6e4;
+var DEFAULT_RELAY_RECONNECT_BASE_MS = 3e3;
+var DEFAULT_RELAY_RECONNECT_MAX_MS = 6e4;
+async function readRelayCooldownDelayMs(paths, now = /* @__PURE__ */ new Date()) {
+  const state = await readLinkState(paths);
+  const reconnect = normalizeRelayReconnectState(state.relayReconnect);
+  const cooldownUntilMs = parseTimeMs(reconnect.cooldownUntil);
+  if (!Number.isFinite(cooldownUntilMs)) {
+    return 0;
+  }
+  return Math.max(0, cooldownUntilMs - now.getTime());
+}
+async function recordRelayDisconnect(paths, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const nowMs = now.getTime();
+  const stormWindowMs = positiveInteger(options.stormWindowMs, DEFAULT_STORM_WINDOW_MS);
+  const stormDisconnectLimit = positiveInteger(
+    options.stormDisconnectLimit,
+    DEFAULT_STORM_DISCONNECT_LIMIT
+  );
+  const cooldownMs = positiveInteger(options.cooldownMs, DEFAULT_COOLDOWN_MS);
+  let result = {
+    disconnectCount: 0,
+    cooldownUntilMs: null
+  };
+  await updateRelayReconnectState(paths, (current) => {
+    const recentDisconnects = [
+      ...current.recentDisconnects.filter((value) => {
+        const timestamp = parseTimeMs(value);
+        return Number.isFinite(timestamp) && nowMs - timestamp <= stormWindowMs;
+      }),
+      now.toISOString()
+    ];
+    const enteredCooldown = recentDisconnects.length >= stormDisconnectLimit;
+    const cooldownUntil = enteredCooldown ? new Date(nowMs + cooldownMs).toISOString() : current.cooldownUntil;
+    const cooldownUntilMs = enteredCooldown ? nowMs + cooldownMs : null;
+    result = {
+      disconnectCount: recentDisconnects.length,
+      cooldownUntilMs
+    };
+    return {
+      recentDisconnects: enteredCooldown ? [] : recentDisconnects,
+      cooldownUntil,
+      lastFailureAt: now.toISOString(),
+      lastFailureReason: normalizeReason(options.reason)
+    };
+  });
+  return result;
+}
+async function clearRelayReconnectState(paths) {
+  await updateRelayReconnectState(paths, (current) => ({
+    ...current,
+    recentDisconnects: [],
+    cooldownUntil: null
+  }));
+}
+function computeRelayBackoffMs(attempt, options = {}) {
+  const baseMs = positiveInteger(options.baseMs, DEFAULT_RELAY_RECONNECT_BASE_MS);
+  const maxMs = positiveInteger(options.maxMs, DEFAULT_RELAY_RECONNECT_MAX_MS);
+  const normalizedAttempt = Math.max(1, Math.floor(attempt));
+  const exponential = Math.min(maxMs, baseMs * 2 ** Math.max(0, normalizedAttempt - 1));
+  const random = options.random ?? Math.random;
+  const ratio = 0.2 + clampRandom(random()) * 0.1;
+  return exponential + Math.floor(exponential * ratio);
+}
+async function updateRelayReconnectState(paths, update) {
+  const state = await readLinkState(paths);
+  const next = {
+    ...state,
+    relayReconnect: update(normalizeRelayReconnectState(state.relayReconnect))
+  };
+  await writeJsonFile(paths.stateFile, next);
+}
+async function readLinkState(paths) {
+  const state = await readJsonFile(paths.stateFile);
+  return state && typeof state === "object" ? state : {};
+}
+function normalizeRelayReconnectState(value) {
+  const record = value && typeof value === "object" ? value : {};
+  return {
+    recentDisconnects: normalizeTimestamps(record.recentDisconnects),
+    cooldownUntil: typeof record.cooldownUntil === "string" ? record.cooldownUntil : null,
+    lastFailureAt: typeof record.lastFailureAt === "string" ? record.lastFailureAt : null,
+    lastFailureReason: typeof record.lastFailureReason === "string" ? record.lastFailureReason : null
+  };
+}
+function normalizeTimestamps(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string" && Number.isFinite(parseTimeMs(item)));
+}
+function normalizeReason(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed.slice(0, 240) : null;
+}
+function positiveInteger(value, fallback) {
+  return Number.isFinite(value) ? Math.max(1, Math.floor(value)) : fallback;
+}
+function parseTimeMs(value) {
+  return typeof value === "string" ? Date.parse(value) : Number.NaN;
+}
+function clampRandom(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(1, Math.max(0, value));
+}
+
 // src/relay/stream-policy.ts
 var DEFAULT_RELAY_STREAM_BATCH_POLICY = {
   flushIntervalMs: 1e3,
@@ -24186,23 +25335,76 @@ function connectRelayControl(options) {
   const wsUrl = new URL(`${options.relayBaseUrl.replace(/\/+$/u, "")}/api/v1/relay/link/connect`);
   wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
   wsUrl.searchParams.set("link_id", options.linkId);
-  const maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
-  const backoffBaseMs = options.backoffBaseMs ?? 1e3;
-  const backoffMaxMs = options.backoffMaxMs ?? 3e4;
+  const paths = options.paths ?? resolveRuntimePaths();
+  const maxReconnectAttempts = options.maxReconnectAttempts ?? Number.POSITIVE_INFINITY;
+  const backoffBaseMs = options.backoffBaseMs ?? DEFAULT_RELAY_RECONNECT_BASE_MS;
+  const backoffMaxMs = options.backoffMaxMs ?? DEFAULT_RELAY_RECONNECT_MAX_MS;
   let reconnectAttempts = 0;
   let closedByUser = false;
   let socket = null;
   let retryTimer = null;
   let abortControllers = /* @__PURE__ */ new Map();
   let fatalRelayRejection = null;
+  let relayRetryAfterMs = null;
   let latestNetworkRoutes = null;
   const streamBatchPolicy = {
     current: options.initialStreamBatchPolicy ?? DEFAULT_RELAY_STREAM_BATCH_POLICY,
     onUpdate: options.onStreamBatchPolicy
   };
+  const startConnect = () => {
+    void waitForPersistedCooldown().then((delay3) => {
+      if (closedByUser) {
+        return;
+      }
+      if (delay3 > 0) {
+        scheduleTimer(delay3, "cooldown", `Relay reconnect cooldown active for ${delay3}ms`);
+        return;
+      }
+      connect();
+    }).catch((error) => {
+      if (closedByUser) {
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      scheduleTimer(backoffBaseMs, "retrying", `Relay connect setup failed: ${message}`);
+    });
+  };
   const connect = () => {
     options.onStatus?.({ state: "connecting", attempt: reconnectAttempts });
     fatalRelayRejection = null;
+    relayRetryAfterMs = null;
+    let closeHandled = false;
+    const handleConnectionClosed = (reason) => {
+      if (closeHandled) {
+        return;
+      }
+      closeHandled = true;
+      abortAll(abortControllers);
+      abortControllers = /* @__PURE__ */ new Map();
+      if (fatalRelayRejection) {
+        options.onStatus?.({
+          state: "failed",
+          attempt: reconnectAttempts,
+          message: fatalRelayRejection
+        });
+        return;
+      }
+      if (closedByUser) {
+        options.onStatus?.({ state: "disconnected", attempt: reconnectAttempts });
+        return;
+      }
+      if (Number.isFinite(maxReconnectAttempts) && reconnectAttempts >= maxReconnectAttempts) {
+        options.onStatus?.({ state: "failed", attempt: reconnectAttempts, message: "Relay reconnect attempts exhausted" });
+        return;
+      }
+      void scheduleReconnect(reason).catch((error) => {
+        if (closedByUser) {
+          return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        scheduleTimer(backoffMaxMs, "retrying", `Relay reconnect scheduling failed: ${message}`);
+      });
+    };
     socket = new WebSocket(wsUrl, {
       headers: {
         "x-hermes-link-version": LINK_VERSION
@@ -24210,6 +25412,7 @@ function connectRelayControl(options) {
     });
     socket.on("open", () => {
       reconnectAttempts = 0;
+      void clearRelayReconnectState(paths).catch(() => void 0);
       options.onStatus?.({ state: "connected", attempt: reconnectAttempts });
       const currentSocket = socket;
       if (currentSocket && latestNetworkRoutes) {
@@ -24225,6 +25428,20 @@ function connectRelayControl(options) {
         socket?.send(JSON.stringify({ type: "http.error", id: "unknown", status: 502, message }));
       });
     });
+    socket.on("unexpected-response", (request, response) => {
+      const statusCode = response.statusCode ?? 0;
+      fatalRelayRejection = resolveFatalRelayRejectionFromStatus(statusCode);
+      relayRetryAfterMs = readRetryAfterMs(response);
+      const message = fatalRelayRejection ?? `Relay returned HTTP ${statusCode || "unknown"}`;
+      options.onStatus?.({
+        state: "disconnected",
+        attempt: reconnectAttempts,
+        message
+      });
+      response.resume();
+      handleConnectionClosed(message);
+      request.destroy();
+    });
     socket.on("error", (error) => {
       const message = error instanceof Error ? error.message : "Relay websocket error";
       fatalRelayRejection = resolveFatalRelayRejection(message);
@@ -24235,32 +25452,40 @@ function connectRelayControl(options) {
       });
     });
     socket.on("close", () => {
-      abortAll(abortControllers);
-      abortControllers = /* @__PURE__ */ new Map();
-      if (fatalRelayRejection) {
-        options.onStatus?.({
-          state: "failed",
-          attempt: reconnectAttempts,
-          message: fatalRelayRejection
-        });
-        return;
-      }
-      if (closedByUser) {
-        options.onStatus?.({ state: "disconnected", attempt: reconnectAttempts });
-        return;
-      }
-      if (reconnectAttempts >= maxReconnectAttempts) {
-        options.onStatus?.({ state: "failed", attempt: reconnectAttempts, message: "Relay reconnect attempts exhausted" });
-        return;
-      }
-      reconnectAttempts += 1;
-      const delay3 = computeBackoffMs(reconnectAttempts, backoffBaseMs, backoffMaxMs);
-      options.onStatus?.({ state: "retrying", attempt: reconnectAttempts, message: `Retrying in ${delay3}ms` });
-      retryTimer = setTimeout(connect, delay3);
-      retryTimer.unref?.();
+      handleConnectionClosed();
     });
   };
-  connect();
+  startConnect();
+  async function scheduleReconnect(reason) {
+    const recorded = await recordRelayDisconnect(paths, { reason }).catch(() => ({
+      disconnectCount: 0,
+      cooldownUntilMs: null
+    }));
+    if (closedByUser) {
+      return;
+    }
+    if (recorded.cooldownUntilMs !== null) {
+      reconnectAttempts = 0;
+      const delay4 = Math.max(0, recorded.cooldownUntilMs - Date.now());
+      scheduleTimer(delay4, "cooldown", `Relay reconnect storm guard active for ${delay4}ms`);
+      return;
+    }
+    reconnectAttempts += 1;
+    const backoffMs = computeRelayBackoffMs(reconnectAttempts, {
+      baseMs: backoffBaseMs,
+      maxMs: backoffMaxMs
+    });
+    const delay3 = Math.max(backoffMs, relayRetryAfterMs ?? 0);
+    scheduleTimer(delay3, "retrying", `Retrying in ${delay3}ms`);
+  }
+  async function waitForPersistedCooldown() {
+    return await readRelayCooldownDelayMs(paths).catch(() => 0);
+  }
+  function scheduleTimer(delay3, state, message) {
+    options.onStatus?.({ state, attempt: reconnectAttempts, message });
+    retryTimer = setTimeout(connect, delay3);
+    retryTimer.unref?.();
+  }
   return {
     publishNetworkRoutes(routes) {
       latestNetworkRoutes = routes;
@@ -24297,7 +25522,12 @@ function sendNetworkRoutes(socket, linkId, routes) {
   }));
 }
 function resolveFatalRelayRejection(message) {
-  if (!/Unexpected server response:\s*(400|401|403|426)\b/u.test(message)) {
+  const match = /Unexpected server response:\s*(\d{3})\b/u.exec(message);
+  const statusCode = match ? Number.parseInt(match[1], 10) : Number.NaN;
+  return resolveFatalRelayRejectionFromStatus(statusCode);
+}
+function resolveFatalRelayRejectionFromStatus(statusCode) {
+  if (!Number.isFinite(statusCode) || ![400, 401, 403, 410, 426].includes(statusCode)) {
     return null;
   }
   return "Relay refused the Hermes Link connection. Check Link version and pairing state before retrying.";
@@ -24308,10 +25538,21 @@ function abortAll(abortControllers) {
   }
   abortControllers.clear();
 }
-function computeBackoffMs(attempt, baseMs, maxMs) {
-  const exponential = Math.min(maxMs, baseMs * 2 ** Math.max(0, attempt - 1));
-  const jitter = Math.floor(Math.random() * Math.min(1e3, exponential * 0.2));
-  return exponential + jitter;
+function readRetryAfterMs(response) {
+  const raw = response.headers["retry-after"];
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  if (!value) {
+    return null;
+  }
+  const seconds = Number.parseInt(value, 10);
+  if (Number.isInteger(seconds) && seconds >= 0) {
+    return seconds * 1e3;
+  }
+  const dateMs = Date.parse(value);
+  if (!Number.isFinite(dateMs)) {
+    return null;
+  }
+  return Math.max(0, dateMs - Date.now());
 }
 async function handleFrame(socket, raw, localPort, abortControllers, streamBatchPolicy) {
   const frame = JSON.parse(raw);
@@ -24432,10 +25673,58 @@ function createRelayStreamChunkBatcher(socket, id, streamBatchPolicy) {
   };
 }
 
+// src/relay/status-state.ts
+async function readRelayStatusSnapshot(paths) {
+  const state = await readLinkState2(paths);
+  return normalizeRelayStatusSnapshot(state.relayStatus);
+}
+async function writeRelayStatusSnapshot(paths, status, now = /* @__PURE__ */ new Date()) {
+  const current = await readLinkState2(paths);
+  await writeJsonFile(paths.stateFile, {
+    ...current,
+    relayStatus: {
+      state: status.state,
+      attempt: Number.isFinite(status.attempt) ? Math.max(0, Math.floor(status.attempt)) : 0,
+      message: normalizeMessage(status.message),
+      updatedAt: now.toISOString()
+    }
+  });
+}
+async function readLinkState2(paths) {
+  const state = await readJsonFile(paths.stateFile);
+  return state && typeof state === "object" ? state : {};
+}
+function normalizeRelayStatusSnapshot(value) {
+  const record = value && typeof value === "object" ? value : null;
+  if (!record || !isRelayStatusState(record.state)) {
+    return null;
+  }
+  const updatedAt = typeof record.updatedAt === "string" && Number.isFinite(Date.parse(record.updatedAt)) ? record.updatedAt : null;
+  if (!updatedAt) {
+    return null;
+  }
+  return {
+    state: record.state,
+    attempt: typeof record.attempt === "number" && Number.isFinite(record.attempt) ? Math.max(0, Math.floor(record.attempt)) : 0,
+    message: normalizeMessage(record.message),
+    updatedAt
+  };
+}
+function isRelayStatusState(value) {
+  return value === "connecting" || value === "connected" || value === "disconnected" || value === "retrying" || value === "cooldown" || value === "failed";
+}
+function normalizeMessage(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed.slice(0, 240) : null;
+}
+
 // src/runtime/system-info.ts
 import { execFileSync } from "child_process";
 import { readFileSync } from "fs";
-import os4 from "os";
+import os5 from "os";
 function readLinkSystemInfo() {
   const platform = process.platform;
   const hostname = readHostname(platform);
@@ -24474,7 +25763,7 @@ function readHostname(platform) {
       return computerName;
     }
   }
-  return normalizeText(os4.hostname());
+  return normalizeText(os5.hostname());
 }
 function readOsLabel(platform) {
   if (platform === "darwin") {
@@ -24482,12 +25771,12 @@ function readOsLabel(platform) {
     return version ? `macOS ${version}` : "macOS";
   }
   if (platform === "linux") {
-    return readLinuxOsRelease() ?? `Linux ${os4.release()}`;
+    return readLinuxOsRelease() ?? `Linux ${os5.release()}`;
   }
   if (platform === "win32") {
-    return `Windows ${os4.release()}`;
+    return `Windows ${os5.release()}`;
   }
-  return `${os4.type()} ${os4.release()}`.trim();
+  return `${os5.type()} ${os5.release()}`.trim();
 }
 function readLinuxOsRelease() {
   for (const file of ["/etc/os-release", "/usr/lib/os-release"]) {
@@ -24534,11 +25823,11 @@ function truncateText(value, maxLength) {
 }
 
 // src/topology/network.ts
-import os6 from "os";
+import os7 from "os";
 
 // src/topology/environment.ts
 import { existsSync, readFileSync as readFileSync2 } from "fs";
-import os5 from "os";
+import os6 from "os";
 function detectRuntimeEnvironment(env = process.env) {
   if (isWsl(env)) {
     return {
@@ -24567,7 +25856,7 @@ function isWsl(env) {
   if (env.WSL_DISTRO_NAME || env.WSL_INTEROP) {
     return true;
   }
-  const release = os5.release().toLowerCase();
+  const release = os6.release().toLowerCase();
   return release.includes("microsoft") || release.includes("wsl");
 }
 function isContainer(env) {
@@ -24612,7 +25901,7 @@ async function discoverRouteCandidates(options) {
   };
 }
 function discoverLanIps() {
-  return discoverLanIpsFromInterfaces(os6.networkInterfaces());
+  return discoverLanIpsFromInterfaces(os7.networkInterfaces());
 }
 function discoverLanIpsFromInterfaces(interfaces) {
   const result = /* @__PURE__ */ new Set();
@@ -24751,7 +26040,7 @@ function unique(values) {
 // src/link/network-report-state.ts
 var DEFAULT_AUTO_DAILY_LIMIT = 20;
 async function readNetworkReportState(paths) {
-  const state = await readLinkState(paths);
+  const state = await readLinkState3(paths);
   return normalizeNetworkReportState(state.networkReport);
 }
 async function markNetworkStatusReported(paths, snapshotInput, reportedAt = /* @__PURE__ */ new Date()) {
@@ -24818,14 +26107,14 @@ async function mergeLastReportedPublicRoutes(paths, snapshotInput) {
   };
 }
 async function updateNetworkReportState(paths, update) {
-  const state = await readLinkState(paths);
+  const state = await readLinkState3(paths);
   const next = {
     ...state,
     networkReport: update(normalizeNetworkReportState(state.networkReport))
   };
   await writeJsonFile(paths.stateFile, next);
 }
-async function readLinkState(paths) {
+async function readLinkState3(paths) {
   const state = await readJsonFile(paths.stateFile);
   return state && typeof state === "object" ? state : {};
 }
@@ -25098,6 +26387,89 @@ async function checkLanIpChange(options, context = {}) {
   }
 }
 
+// src/daemon/process-guard.ts
+var installed = false;
+var fatalShutdownInProgress = false;
+var activeLogger = null;
+var activeOptions = {};
+var DEFAULT_FATAL_SHUTDOWN_TIMEOUT_MS = 5e3;
+function installDaemonProcessGuard(logger, options = {}) {
+  activeLogger = logger;
+  activeOptions = options;
+  if (installed) {
+    return;
+  }
+  installed = true;
+  process.on("unhandledRejection", (reason) => {
+    void handleFatalProcessFailure("process_unhandled_rejection", reason);
+  });
+  process.on("uncaughtException", (error) => {
+    void handleFatalProcessFailure("process_uncaught_exception", error);
+  });
+}
+async function handleFatalProcessFailure(event, error) {
+  const fields = describeProcessFailure(error);
+  const logger = activeLogger;
+  const options = activeOptions;
+  if (fatalShutdownInProgress) {
+    writeFatalFailureToStderr(event, fields);
+    return;
+  }
+  fatalShutdownInProgress = true;
+  if (logger) {
+    try {
+      await logger.error(event, fields);
+      await logger.flush();
+    } catch {
+    }
+  }
+  writeFatalFailureToStderr(event, fields);
+  if (options.onFatal) {
+    try {
+      await Promise.race([
+        options.onFatal(),
+        wait(options.shutdownTimeoutMs ?? DEFAULT_FATAL_SHUTDOWN_TIMEOUT_MS)
+      ]);
+    } catch (shutdownError) {
+      if (logger) {
+        try {
+          await logger.error("process_fatal_shutdown_failed", {
+            error: shutdownError instanceof Error ? shutdownError.message : String(shutdownError)
+          });
+          await logger.flush();
+        } catch {
+        }
+      }
+    }
+  }
+  process.exit(1);
+}
+function describeProcessFailure(error) {
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      ...error.stack ? { stack: error.stack } : {}
+    };
+  }
+  return { message: String(error) };
+}
+function writeFatalFailureToStderr(event, fields) {
+  try {
+    process.stderr.write(
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] ${event}: ${fields.message}
+${fields.stack ?? ""}
+`
+    );
+  } catch {
+  }
+}
+function wait(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+
 // src/daemon/scheduler.ts
 function startCronDeliveryScheduler(options) {
   let running = false;
@@ -25183,6 +26555,11 @@ async function startLinkService(options = {}) {
       current_version: migration.currentVersion
     });
   }
+  await ensureHermesLinkSkillInstalledBestEffort({
+    paths,
+    logger,
+    source: "service_startup"
+  });
   const conversations = new ConversationService(paths, logger);
   await conversations.rebuildStatisticsIndex();
   let relay = null;
@@ -25214,6 +26591,11 @@ async function startLinkService(options = {}) {
     logger,
     conversations,
     onPairingClaimed: async () => {
+      void ensureHermesLinkSkillInstalledBestEffort({
+        paths,
+        logger,
+        source: "pairing_claimed"
+      });
       triggerHermesSessionSync();
       void loadRelayStreamBatchPolicy("pairing_claimed");
       await options.onPairingClaimed?.();
@@ -25238,6 +26620,38 @@ async function startLinkService(options = {}) {
       error: error.message
     });
   });
+  server.on("clientError", (error, socket) => {
+    if (isExpectedClientDisconnectError3(error, {
+      sse: isActiveSseSocket(socket)
+    })) {
+      socket.destroy();
+      return;
+    }
+    void logger.warn("client_connection_error", {
+      port: config.port,
+      link_id: identity?.link_id ?? null,
+      error: error.message
+    });
+    if (socket.writable) {
+      socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+    } else {
+      socket.destroy();
+    }
+  });
+  server.on("connection", (socket) => {
+    socket.on("error", (error) => {
+      if (isExpectedClientDisconnectError3(error, {
+        sse: isActiveSseSocket(socket)
+      })) {
+        return;
+      }
+      void logger.warn("socket_error", {
+        port: config.port,
+        link_id: identity?.link_id ?? null,
+        error: error.message
+      });
+    });
+  });
   void logger.info("service_started", {
     port: config.port,
     link_id: identity?.link_id ?? null
@@ -25263,9 +26677,8 @@ async function startLinkService(options = {}) {
       relayBaseUrl: config.relayBaseUrl,
       linkId: identity.link_id,
       localPort: config.port,
-      maxReconnectAttempts: options.relayMaxReconnectAttempts ?? 5,
-      backoffBaseMs: 1e3,
-      backoffMaxMs: 3e4,
+      paths,
+      maxReconnectAttempts: options.relayMaxReconnectAttempts,
       onStreamBatchPolicy: (policy) => {
         void logger.info("relay_stream_policy_updated", {
           flushIntervalMs: policy.flushIntervalMs,
@@ -25273,6 +26686,7 @@ async function startLinkService(options = {}) {
         });
       },
       onStatus: (status) => {
+        void writeRelayStatusSnapshot(paths, status).catch(() => void 0);
         void logger.info("relay_status", status);
         if (status.state === "connected") {
           const now = Date.now();
@@ -25313,8 +26727,13 @@ async function startLinkService(options = {}) {
   if (options.writePidFile) {
     await writePidFile(paths);
   }
-  return {
+  let closed = false;
+  const service = {
     async close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
       relay?.close();
       await closeServer(server);
       await Promise.all([
@@ -25330,6 +26749,12 @@ async function startLinkService(options = {}) {
       }
     }
   };
+  if (options.writePidFile) {
+    installDaemonProcessGuard(logger, {
+      onFatal: () => service.close()
+    });
+  }
+  return service;
 }
 function waitForRelayReadyTimeout(timeoutMs) {
   return new Promise((resolve) => {
@@ -25384,6 +26809,16 @@ async function closeServer(server) {
     server.closeIdleConnections?.();
   });
 }
+function isExpectedClientDisconnectError3(error, options = {}) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = String(error.code ?? "");
+  if (code === "ECONNRESET" || code === "EPIPE" || code === "ECONNABORTED" || /(?:socket hang up|aborted)/iu.test(error.message)) {
+    return true;
+  }
+  return options.sse === true && (code === "ETIMEDOUT" || /\b(?:read\s+)?ETIMEDOUT\b/iu.test(error.message));
+}
 async function listenServer(server, port) {
   await new Promise((resolve, reject) => {
     const cleanup = () => {
@@ -25405,6 +26840,16 @@ async function listenServer(server, port) {
 }
 
 // src/daemon/process.ts
+var SUPERVISOR_RESTART_INITIAL_DELAY_MS = 1e3;
+var SUPERVISOR_RESTART_MAX_DELAY_MS = 3e4;
+var SUPERVISOR_STABLE_UPTIME_MS = 6e4;
+var SUPERVISOR_HEALTH_STARTUP_GRACE_MS = 15e3;
+var SUPERVISOR_HEALTH_INTERVAL_MS = 15e3;
+var SUPERVISOR_HEALTH_TIMEOUT_MS = 3e3;
+var SUPERVISOR_HEALTH_FAILURE_THRESHOLD = 3;
+var SUPERVISOR_CHILD_STOP_TIMEOUT_MS = 5e3;
+var SUPERVISOR_STOP_INTENT_TTL_MS = 2 * 6e4;
+var INTERNAL_HEALTH_PROBE_HEADER2 = "x-hermes-link-internal-health-probe";
 async function startDaemonProcess(paths = resolveRuntimePaths()) {
   const config = await loadConfig(paths);
   let status = await getDaemonStatus(paths);
@@ -25429,7 +26874,7 @@ async function startDaemonProcess(paths = resolveRuntimePaths()) {
   });
   child.unref();
   for (let index = 0; index < 12; index += 1) {
-    await wait(250);
+    await wait2(250);
     const next = await getDaemonStatus(paths);
     if (next.running && (await probeLocalLinkService({ port: config.port, timeoutMs: 500 })).reachable) {
       return next;
@@ -25441,43 +26886,92 @@ async function runDaemonSupervisor(paths = resolveRuntimePaths()) {
   await mkdir14(paths.logsDir, { recursive: true, mode: 448 });
   const log = createRotatingTextLogWriter({
     paths,
-    fileName: path25.basename(daemonLogFile(paths))
+    fileName: path26.basename(daemonLogFile(paths))
   });
   const scriptPath = currentCliScriptPath();
-  const child = spawn4(process.execPath, [scriptPath, "daemon", "--foreground"], {
-    stdio: ["ignore", "pipe", "pipe"],
-    env: process.env
-  });
   const write = (chunk) => {
     void log.write(chunk);
   };
   write(`[${(/* @__PURE__ */ new Date()).toISOString()}] daemon supervisor started
 `);
-  child.stdout?.on("data", write);
-  child.stderr?.on("data", write);
+  await clearExpiredSupervisorStopIntent(paths).catch(() => void 0);
+  const logSupervisorUnhandledRejection = (reason) => {
+    writeSupervisorFailure(write, "supervisor_unhandled_rejection", reason);
+  };
+  const logSupervisorUncaughtException = (error) => {
+    writeSupervisorFailure(write, "supervisor_uncaught_exception", error);
+  };
+  let child = null;
+  let stopRequested = false;
   const forwardStop = () => {
-    if (child.pid && isProcessAlive3(child.pid)) {
+    stopRequested = true;
+    if (child?.pid && isProcessAlive3(child.pid)) {
       child.kill("SIGTERM");
     }
   };
   process.once("SIGINT", forwardStop);
   process.once("SIGTERM", forwardStop);
-  const result = await new Promise((resolve, reject) => {
-    child.once("error", reject);
-    child.once("exit", (code, signal) => resolve({ code, signal }));
-  }).catch((error) => {
-    write(`[${(/* @__PURE__ */ new Date()).toISOString()}] daemon supervisor failed: ${error instanceof Error ? error.message : String(error)}
-`);
-    return { code: 1, signal: null };
-  });
-  process.off("SIGINT", forwardStop);
-  process.off("SIGTERM", forwardStop);
+  process.on("unhandledRejection", logSupervisorUnhandledRejection);
+  process.on("uncaughtException", logSupervisorUncaughtException);
+  let restartDelayMs = SUPERVISOR_RESTART_INITIAL_DELAY_MS;
+  let finalResult = {
+    code: 0,
+    signal: null
+  };
+  try {
+    while (!stopRequested) {
+      const startedAt = Date.now();
+      child = spawn4(process.execPath, [scriptPath, "daemon", "--foreground"], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env
+      });
+      const childPid = child.pid ?? null;
+      child.stdout?.on("data", write);
+      child.stderr?.on("data", write);
+      const healthMonitor = startSupervisorHealthMonitor(paths, child, write);
+      const result = await new Promise((resolve, reject) => {
+        child?.once("error", reject);
+        child?.once("exit", (code, signal) => resolve({ code, signal }));
+      }).catch((error) => {
+        write(
+          `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon child failed to start: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+        return { code: 1, signal: null };
+      });
+      healthMonitor.close();
+      finalResult = result;
+      child = null;
+      const expectedStop = childPid !== null && await consumeSupervisorStopIntent(paths, childPid);
+      if (stopRequested || expectedStop || result.code === 0 || isIntentionalStopSignal(result.signal)) {
+        break;
+      }
+      const uptimeMs = Date.now() - startedAt;
+      if (uptimeMs >= SUPERVISOR_STABLE_UPTIME_MS) {
+        restartDelayMs = SUPERVISOR_RESTART_INITIAL_DELAY_MS;
+      }
+      write(
+        `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon child stopped unexpectedly code=${result.code ?? "null"} signal=${result.signal ?? "null"}; restarting in ${restartDelayMs}ms
+`
+      );
+      await wait2(restartDelayMs);
+      restartDelayMs = Math.min(
+        restartDelayMs * 2,
+        SUPERVISOR_RESTART_MAX_DELAY_MS
+      );
+    }
+  } finally {
+    process.off("SIGINT", forwardStop);
+    process.off("SIGTERM", forwardStop);
+    process.off("unhandledRejection", logSupervisorUnhandledRejection);
+    process.off("uncaughtException", logSupervisorUncaughtException);
+  }
   write(
-    `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon supervisor stopped code=${result.code ?? "null"} signal=${result.signal ?? "null"}
+    `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon supervisor stopped code=${finalResult.code ?? "null"} signal=${finalResult.signal ?? "null"}
 `
   );
   await log.flush();
-  return result.code ?? (result.signal ? 0 : 1);
+  return finalResult.code ?? (finalResult.signal ? 0 : 1);
 }
 async function probeLocalLinkService(options) {
   const unreachable = {
@@ -25515,6 +27009,7 @@ async function stopDaemonProcess(paths = resolveRuntimePaths()) {
   if (!status.running || !status.pid) {
     return status;
   }
+  await writeSupervisorStopIntent(paths, status.pid).catch(() => void 0);
   try {
     process.kill(status.pid, "SIGTERM");
   } catch {
@@ -25522,7 +27017,7 @@ async function stopDaemonProcess(paths = resolveRuntimePaths()) {
     return await getDaemonStatus(paths);
   }
   for (let index = 0; index < 20; index += 1) {
-    await wait(250);
+    await wait2(250);
     if (!isProcessAlive3(status.pid)) {
       break;
     }
@@ -25533,7 +27028,7 @@ async function stopDaemonProcess(paths = resolveRuntimePaths()) {
     } catch {
     }
     for (let index = 0; index < 10; index += 1) {
-      await wait(250);
+      await wait2(250);
       if (!isProcessAlive3(status.pid)) {
         break;
       }
@@ -25570,7 +27065,7 @@ function currentCliScriptPath() {
   return process.argv[1];
 }
 async function readPid(filePath) {
-  const raw = await readFile18(filePath, "utf8").catch(() => null);
+  const raw = await readFile19(filePath, "utf8").catch(() => null);
   if (!raw) {
     return null;
   }
@@ -25585,6 +27080,171 @@ function isProcessAlive3(pid) {
     return false;
   }
 }
+function isIntentionalStopSignal(signal) {
+  return signal === "SIGINT" || signal === "SIGTERM" || signal === "SIGKILL";
+}
+function startSupervisorHealthMonitor(paths, child, write) {
+  let closed = false;
+  let failureCount = 0;
+  let timer = null;
+  let forceKillTimer = null;
+  const schedule = (delayMs) => {
+    timer = setTimeout(check, delayMs);
+    timer.unref?.();
+  };
+  const check = () => {
+    void probeSupervisorHttpHealth(paths).then((healthy) => {
+      if (closed) {
+        return;
+      }
+      if (healthy) {
+        failureCount = 0;
+        schedule(SUPERVISOR_HEALTH_INTERVAL_MS);
+        return;
+      }
+      failureCount += 1;
+      if (failureCount < SUPERVISOR_HEALTH_FAILURE_THRESHOLD) {
+        schedule(SUPERVISOR_HEALTH_INTERVAL_MS);
+        return;
+      }
+      closed = true;
+      write(
+        `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon child health probe failed ${failureCount} consecutive times; restarting child
+`
+      );
+      terminateChild(child, forceKillTimer);
+      forceKillTimer = setTimeout(() => {
+        if (child.pid && isProcessAlive3(child.pid)) {
+          child.kill("SIGKILL");
+        }
+      }, SUPERVISOR_CHILD_STOP_TIMEOUT_MS);
+      forceKillTimer.unref?.();
+    }).catch((error) => {
+      if (closed) {
+        return;
+      }
+      failureCount += 1;
+      write(
+        `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon child health probe failed: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+      if (failureCount >= SUPERVISOR_HEALTH_FAILURE_THRESHOLD) {
+        closed = true;
+        terminateChild(child, forceKillTimer);
+        forceKillTimer = setTimeout(() => {
+          if (child.pid && isProcessAlive3(child.pid)) {
+            child.kill("SIGKILL");
+          }
+        }, SUPERVISOR_CHILD_STOP_TIMEOUT_MS);
+        forceKillTimer.unref?.();
+        return;
+      }
+      schedule(SUPERVISOR_HEALTH_INTERVAL_MS);
+    });
+  };
+  schedule(SUPERVISOR_HEALTH_STARTUP_GRACE_MS);
+  return {
+    close() {
+      closed = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      if (forceKillTimer) {
+        clearTimeout(forceKillTimer);
+        forceKillTimer = null;
+      }
+    }
+  };
+}
+async function probeSupervisorHttpHealth(paths) {
+  const config = await loadConfig(paths).catch(() => null);
+  if (!config) {
+    return false;
+  }
+  try {
+    const response = await fetch(`http://127.0.0.1:${config.port}/api/v1/bootstrap`, {
+      headers: {
+        accept: "application/json",
+        [INTERNAL_HEALTH_PROBE_HEADER2]: "1"
+      },
+      signal: AbortSignal.timeout(SUPERVISOR_HEALTH_TIMEOUT_MS)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function terminateChild(child, previousForceKillTimer) {
+  if (previousForceKillTimer) {
+    clearTimeout(previousForceKillTimer);
+  }
+  if (child.pid && isProcessAlive3(child.pid)) {
+    child.kill("SIGTERM");
+  }
+}
+function supervisorStopIntentPath(paths) {
+  return path26.join(paths.runDir, "supervisor-stop-intent.json");
+}
+async function writeSupervisorStopIntent(paths, pid) {
+  await mkdir14(paths.runDir, { recursive: true, mode: 448 });
+  await writeFile4(
+    supervisorStopIntentPath(paths),
+    `${JSON.stringify({ pid, created_at: (/* @__PURE__ */ new Date()).toISOString() })}
+`,
+    { mode: 384 }
+  );
+}
+async function consumeSupervisorStopIntent(paths, pid) {
+  const filePath = supervisorStopIntentPath(paths);
+  const raw = await readFile19(filePath, "utf8").catch(() => null);
+  if (!raw) {
+    return false;
+  }
+  const payload = parseSupervisorStopIntent(raw);
+  if (!isValidSupervisorStopIntent(payload)) {
+    await rm9(filePath, { force: true }).catch(() => void 0);
+    return false;
+  }
+  if (payload.pid !== pid) {
+    await rm9(filePath, { force: true }).catch(() => void 0);
+    return false;
+  }
+  await rm9(filePath, { force: true }).catch(() => void 0);
+  return true;
+}
+async function clearExpiredSupervisorStopIntent(paths) {
+  const filePath = supervisorStopIntentPath(paths);
+  const raw = await readFile19(filePath, "utf8").catch(() => null);
+  if (!raw) {
+    return;
+  }
+  const payload = parseSupervisorStopIntent(raw);
+  if (!isValidSupervisorStopIntent(payload)) {
+    await rm9(filePath, { force: true }).catch(() => void 0);
+  }
+}
+function parseSupervisorStopIntent(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function isValidSupervisorStopIntent(payload) {
+  if (typeof payload.pid !== "number" || !Number.isInteger(payload.pid) || typeof payload.created_at !== "string") {
+    return false;
+  }
+  const createdAtMs = Date.parse(payload.created_at);
+  return Number.isFinite(createdAtMs) && Date.now() - createdAtMs <= SUPERVISOR_STOP_INTENT_TTL_MS;
+}
+function writeSupervisorFailure(write, event, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const stack = error instanceof Error && error.stack ? `
+${error.stack}` : "";
+  write(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${event}: ${message}${stack}
+`);
+}
 async function pidBackedServiceIsReachable(paths) {
   const config = await loadConfig(paths).catch(() => null);
   if (!config) {
@@ -25592,7 +27252,7 @@ async function pidBackedServiceIsReachable(paths) {
   }
   return (await probeLocalLinkService({ port: config.port, timeoutMs: 500 })).reachable;
 }
-function wait(ms) {
+function wait2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
@@ -25999,7 +27659,7 @@ async function readRemoteLinkPolicy(options) {
   }
 }
 function normalizeServerSnapshot(payload) {
-  const snapshot = toRecord19(payload);
+  const snapshot = toRecord20(payload);
   const policy = toNullableRecord2(snapshot.policy);
   if (!policy) {
     return {
@@ -26342,7 +28002,7 @@ async function writeUpdateState2(paths, state) {
   await writeJsonFile(updateStatePath2(paths), state);
 }
 async function readUpdateLogLines2(paths) {
-  const raw = await readFile19(updateLogPath2(paths), "utf8").catch(() => "");
+  const raw = await readFile20(updateLogPath2(paths), "utf8").catch(() => "");
   if (!raw.trim()) {
     return [];
   }
@@ -26351,10 +28011,10 @@ async function readUpdateLogLines2(paths) {
   );
 }
 function updateStatePath2(paths) {
-  return path26.join(paths.runDir, "link-update-state.json");
+  return path27.join(paths.runDir, "link-update-state.json");
 }
 function updateLogPath2(paths) {
-  return path26.join(paths.logsDir, UPDATE_LOG_FILE2);
+  return path27.join(paths.logsDir, UPDATE_LOG_FILE2);
 }
 async function clearUpdateLogFiles2(paths) {
   const primary = updateLogPath2(paths);
@@ -26426,7 +28086,7 @@ function isProcessAlive4(pid) {
     return false;
   }
 }
-function toRecord19(value) {
+function toRecord20(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function toNullableRecord2(value) {
@@ -26438,7 +28098,7 @@ function readString20(payload, key) {
 }
 
 // src/pairing/pairing.ts
-import path27 from "path";
+import path28 from "path";
 import { rm as rm11 } from "fs/promises";
 
 // src/relay/bootstrap.ts
@@ -26778,10 +28438,10 @@ async function loadRequiredIdentity2(paths) {
   }
   return identity;
 }
-async function postServerJson(serverBaseUrl, path28, body, options) {
+async function postServerJson(serverBaseUrl, path29, body, options) {
   let response;
   try {
-    response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path28}`, {
+    response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path29}`, {
       method: "POST",
       headers: {
         accept: "application/json",
@@ -26829,10 +28489,10 @@ function pairingErrorSnapshot(stage, error) {
     occurred_at: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-async function patchServerJson(serverBaseUrl, path28, token, body, options) {
+async function patchServerJson(serverBaseUrl, path29, token, body, options) {
   let response;
   try {
-    response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path28}`, {
+    response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path29}`, {
       method: "PATCH",
       headers: {
         accept: "application/json",
@@ -26880,10 +28540,10 @@ function createPairingNetworkError(input) {
   );
 }
 function pairingClaimPath(sessionId, paths) {
-  return path27.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.claimed.json`);
+  return path28.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.claimed.json`);
 }
 function pairingSessionPath(sessionId, paths) {
-  return path27.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.json`);
+  return path28.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.json`);
 }
 function qrPreferredUrls(routes) {
   return routes.preferredUrls.filter((url) => !url.includes("/api/v1/relay/links/")).slice(0, 1);
@@ -26997,7 +28657,12 @@ function registerSystemRoutes(router, options) {
           error: error instanceof Error ? error.message : String(error)
         });
       });
-      void options.onPairingClaimed?.();
+      void Promise.resolve().then(() => options.onPairingClaimed?.()).catch((error) => {
+        void logger.warn("pairing_claim_callback_failed", {
+          session_id: sessionId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
     }, 250);
     timer.unref?.();
   });
@@ -28035,6 +29700,18 @@ async function createApp(options = {}) {
   };
   const app = new Koa();
   const router = new Router();
+  app.on("error", (error, ctx) => {
+    if (isExpectedClientDisconnectError2(error, {
+      sse: isSseRequestContext(ctx)
+    })) {
+      return;
+    }
+    void logger.error("http_app_error", {
+      method: ctx?.method ?? null,
+      path: ctx?.path ?? null,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  });
   app.use(createHttpErrorMiddleware(logger));
   registerSystemRoutes(router, {
     paths,
@@ -28073,6 +29750,11 @@ export {
   resolveRuntimePaths,
   createFileLogger,
   getLinkLogFile,
+  readRecentLogEntries,
+  readRecentTextLogEntries,
+  getGatewayLogFiles,
+  readRecentGatewayLogEntries,
+  flushLogFiles,
   ensureHermesApiServerAvailable,
   readHermesVersion,
   defaultLinkConfig,
@@ -28085,6 +29767,7 @@ export {
   getIdentityStatus,
   ConversationService,
   hasActiveDevices,
+  ensureHermesLinkSkillInstalledBestEffort,
   detectRuntimeEnvironment,
   preparePairing,
   readPairingClaim,
@@ -28092,6 +29775,7 @@ export {
   createApp,
   fetchRelayStreamBatchPolicy,
   connectRelayControl,
+  readRelayStatusSnapshot,
   reportLinkStatusToServer,
   startLinkService,
   startDaemonProcess,