@hermespilot/link 0.3.4 → 0.3.6

package/dist/{chunk-FPMMWYXK.js → chunk-773L37RF.js}

@@ -4,7 +4,7 @@ import Router from "@koa/router";
 
 // src/conversations/conversation-service.ts
 import { EventEmitter } from "events";
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/database/link-database.ts
 import { mkdir } from "fs/promises";
@@ -3637,7 +3637,7 @@ async function listCronOutputFiles(profileName, jobId) {
       mtimeMs: fileStat.mtimeMs
     });
   }
-  return files.sort((left, right) => left.mtimeMs - right.mtimeMs).map(({ path: path24, mtime }) => ({ path: path24, mtime }));
+  return files.sort((left, right) => left.mtimeMs - right.mtimeMs).map(({ path: path25, mtime }) => ({ path: path25, mtime }));
 }
 async function readCronOutput(outputPath) {
   const content = await readFile3(outputPath, "utf8");
@@ -3724,7 +3724,7 @@ import os2 from "os";
 import path5 from "path";
 
 // src/constants.ts
-var LINK_VERSION = "0.3.4";
+var LINK_VERSION = "0.3.6";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -4859,6 +4859,9 @@ function toRecord3(value) {
 }
 
 // src/conversations/statistics.ts
+var ESTIMATED_CONTEXT_CHARS_PER_TOKEN = 4;
+var ESTIMATED_CONTEXT_BASE_OVERHEAD_TOKENS = 256;
+var ESTIMATED_CONTEXT_PER_MESSAGE_OVERHEAD_TOKENS = 8;
 function buildConversationStats(manifest, snapshot) {
   if (manifest.stats && manifest.status !== "active" && snapshot.messages.length === 0 && snapshot.runs.length === 0) {
     return manifest.stats;
@@ -4973,12 +4976,21 @@ function readUsage(payload) {
     return void 0;
   }
   const usage = toRecord4(payload.usage);
-  const inputTokens = readInteger(usage, "input_tokens") ?? readInteger(usage, "prompt_tokens") ?? readInteger(payload, "input_tokens") ?? readInteger(payload, "prompt_tokens");
-  const outputTokens = readInteger(usage, "output_tokens") ?? readInteger(usage, "completion_tokens") ?? readInteger(payload, "output_tokens") ?? readInteger(payload, "completion_tokens");
-  const totalTokens = readInteger(usage, "total_tokens") ?? readInteger(payload, "total_tokens") ?? (inputTokens ?? 0) + (outputTokens ?? 0);
-  const contextWindow = readInteger(usage, "context_window") ?? readInteger(usage, "context_max") ?? readInteger(payload, "context_window") ?? readInteger(payload, "context_max");
-  const explicitContextTokens = readInteger(usage, "context_tokens") ?? readInteger(usage, "context_used") ?? readInteger(usage, "current_context_tokens") ?? readInteger(usage, "last_prompt_tokens") ?? readInteger(payload, "context_tokens") ?? readInteger(payload, "context_used") ?? readInteger(payload, "current_context_tokens") ?? readInteger(payload, "last_prompt_tokens");
-  if (!inputTokens && !outputTokens && !totalTokens) {
+  const response = toRecord4(payload.response);
+  const responseUsage = toRecord4(response.usage);
+  const context = firstRecord(
+    payload.context,
+    usage.context,
+    response.context,
+    responseUsage.context
+  );
+  const inputTokens = readInteger(usage, "input_tokens") ?? readInteger(usage, "prompt_tokens") ?? readInteger(responseUsage, "input_tokens") ?? readInteger(responseUsage, "prompt_tokens") ?? readInteger(payload, "input_tokens") ?? readInteger(payload, "prompt_tokens");
+  const outputTokens = readInteger(usage, "output_tokens") ?? readInteger(usage, "completion_tokens") ?? readInteger(responseUsage, "output_tokens") ?? readInteger(responseUsage, "completion_tokens") ?? readInteger(payload, "output_tokens") ?? readInteger(payload, "completion_tokens");
+  const totalTokens = readInteger(usage, "total_tokens") ?? readInteger(responseUsage, "total_tokens") ?? readInteger(payload, "total_tokens") ?? (inputTokens ?? 0) + (outputTokens ?? 0);
+  const contextWindow = readInteger(context, "window_tokens") ?? readInteger(context, "windowTokens") ?? readInteger(context, "context_window") ?? readInteger(context, "context_max") ?? readInteger(context, "context_length") ?? readInteger(usage, "context_window") ?? readInteger(usage, "context_max") ?? readInteger(usage, "context_length") ?? readInteger(responseUsage, "context_window") ?? readInteger(responseUsage, "context_max") ?? readInteger(responseUsage, "context_length") ?? readInteger(response, "context_window") ?? readInteger(response, "context_max") ?? readInteger(response, "context_length") ?? readInteger(payload, "context_window") ?? readInteger(payload, "context_max") ?? readInteger(payload, "context_length");
+  const explicitContextTokens = readInteger(context, "used_tokens") ?? readInteger(context, "usedTokens") ?? readInteger(context, "context_tokens") ?? readInteger(context, "context_used") ?? readInteger(context, "current_context_tokens") ?? readInteger(context, "last_prompt_tokens") ?? readInteger(usage, "context_tokens") ?? readInteger(usage, "context_used") ?? readInteger(usage, "current_context_tokens") ?? readInteger(usage, "last_prompt_tokens") ?? readInteger(responseUsage, "context_tokens") ?? readInteger(responseUsage, "context_used") ?? readInteger(responseUsage, "current_context_tokens") ?? readInteger(responseUsage, "last_prompt_tokens") ?? readInteger(response, "context_tokens") ?? readInteger(response, "context_used") ?? readInteger(response, "current_context_tokens") ?? readInteger(response, "last_prompt_tokens") ?? readInteger(payload, "context_tokens") ?? readInteger(payload, "context_used") ?? readInteger(payload, "current_context_tokens") ?? readInteger(payload, "last_prompt_tokens");
+  const explicitUsagePercent = readInteger(context, "usage_percent") ?? readInteger(context, "context_percent") ?? readInteger(usage, "usage_percent") ?? readInteger(usage, "context_percent") ?? readInteger(responseUsage, "usage_percent") ?? readInteger(responseUsage, "context_percent") ?? readInteger(response, "usage_percent") ?? readInteger(response, "context_percent") ?? readInteger(payload, "usage_percent") ?? readInteger(payload, "context_percent");
+  if (!inputTokens && !outputTokens && !totalTokens && explicitContextTokens === void 0) {
     return void 0;
   }
   return {
@@ -4987,14 +4999,44 @@ function readUsage(payload) {
     total_tokens: totalTokens,
     ...explicitContextTokens !== void 0 ? { context_tokens: explicitContextTokens } : {},
     ...contextWindow !== void 0 ? { context_window: contextWindow } : {},
+    ...explicitContextTokens !== void 0 ? { context_source: "explicit" } : {},
     ...explicitContextTokens !== void 0 && contextWindow ? {
-      usage_percent: Math.min(
+      usage_percent: explicitUsagePercent !== void 0 ? Math.min(100, explicitUsagePercent) : Math.min(
         100,
         Math.round(explicitContextTokens / contextWindow * 100)
       )
     } : {}
   };
 }
+function estimateContextUsage(input) {
+  const currentInput = input.currentInput.trim();
+  const instructions = input.instructions?.trim() ?? "";
+  const messageCount = input.conversationHistory.length + (currentInput ? 1 : 0) + (instructions ? 1 : 0);
+  if (messageCount === 0) {
+    return void 0;
+  }
+  const serializedRequest = JSON.stringify({
+    instructions: instructions || void 0,
+    conversation_history: input.conversationHistory,
+    input: currentInput || void 0
+  });
+  const estimatedTokens = Math.ceil(serializedRequest.length / ESTIMATED_CONTEXT_CHARS_PER_TOKEN) + ESTIMATED_CONTEXT_BASE_OVERHEAD_TOKENS + messageCount * ESTIMATED_CONTEXT_PER_MESSAGE_OVERHEAD_TOKENS;
+  const contextTokens = input.contextWindow ? Math.min(input.contextWindow, estimatedTokens) : estimatedTokens;
+  return {
+    input_tokens: 0,
+    output_tokens: 0,
+    total_tokens: 0,
+    context_tokens: contextTokens,
+    ...input.contextWindow !== void 0 ? { context_window: input.contextWindow } : {},
+    ...input.contextWindow ? {
+      usage_percent: Math.min(
+        100,
+        Math.round(contextTokens / input.contextWindow * 100)
+      )
+    } : {},
+    context_source: "estimated"
+  };
+}
 function isAgentRun(run) {
   return run.kind !== "command";
 }
@@ -5015,6 +5057,14 @@ function readInteger(payload, key) {
 function toRecord4(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
+function firstRecord(...values) {
+  for (const value of values) {
+    if (typeof value === "object" && value !== null) {
+      return value;
+    }
+  }
+  return {};
+}
 
 // src/conversations/blob-store.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -5730,7 +5780,7 @@ async function buildConversationRuntimeMetadata(paths, manifest, snapshot) {
   };
   const contextWindow = current.contextWindow ?? usage.context_window ?? usageRun?.context_window;
   const contextTokens = usage.context_tokens;
-  const contextSource = contextTokens === void 0 ? "unknown" : "explicit";
+  const contextSource = contextTokens === void 0 ? "unknown" : usage.context_source ?? "explicit";
   const provider = current.provider ?? usageRun?.provider;
   const reasoningEffort = current.reasoningEffort;
   return {
@@ -6324,12 +6374,12 @@ var ConversationCommandHandlers = class {
 };
 function formatContextUsageLines(runtime) {
   const windowTokens = runtime.context.window_tokens ?? runtime.context.context_window;
-  if (runtime.context.source === "explicit") {
+  if (runtime.context.source === "explicit" || runtime.context.source === "estimated") {
     const usedTokens = runtime.context.used_tokens ?? runtime.context.input_tokens;
     const percent = runtime.context.usage_percent ?? (windowTokens && windowTokens > 0 ? Math.min(100, Math.round(usedTokens / windowTokens * 100)) : void 0);
     return [
       `\u4E0A\u4E0B\u6587\uFF1A${usedTokens}${windowTokens ? ` / ${windowTokens}` : ""}${percent === void 0 ? "" : `\uFF08${percent}%\uFF09`}`,
-      "\u6765\u6E90\uFF1A\u6A21\u578B\u8FD4\u56DE"
+      runtime.context.source === "estimated" ? "\u6765\u6E90\uFF1A\u672C\u5730\u4F30\u7B97" : "\u6765\u6E90\uFF1A\u6A21\u578B\u8FD4\u56DE"
     ];
   }
   return [
@@ -8516,6 +8566,13 @@ function isNodeError8(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 
+// src/conversations/hermes-session-sync.ts
+import { randomUUID as randomUUID6 } from "crypto";
+import { readdir as readdir6, readFile as readFile9, stat as stat8 } from "fs/promises";
+import { createRequire as createRequire3 } from "module";
+import os4 from "os";
+import path14 from "path";
+
 // src/conversations/delivery-import.ts
 import { lstat, readFile as readFile8, readdir as readdir5, stat as stat7 } from "fs/promises";
 import path13 from "path";
@@ -8846,145 +8903,1431 @@ function isNodeError9(error, code) {
   return typeof error === "object" && error !== null && "code" in error && (code === void 0 || error.code === code);
 }
 
-// src/conversations/run-lifecycle.ts
-import { readdir as readdir6 } from "fs/promises";
-
-// src/hermes/api-server.ts
-async function listHermesModels(options = {}) {
-  const response = await callHermesApi("/v1/models", { method: "GET" }, options);
-  if (response.status === 404) {
-    return { models: [] };
+// src/conversations/hermes-session-sync.ts
+var nodeRequire3 = createRequire3(import.meta.url);
+var PROFILE_NAME_PATTERN3 = /^[a-zA-Z0-9._-]{1,64}$/u;
+var DEFAULT_PROFILE_NAME = "default";
+var MAX_IMPORTABLE_SESSIONS = 100;
+var HIDDEN_SESSION_SOURCES = /* @__PURE__ */ new Set(["tool"]);
+var HERMES_IMPORT_PROJECTION_VERSION = "turn_blocks_v3";
+var IMPORTED_MEDIA_PLACEHOLDER_RUN_ID = "imported_from_hermes";
+var MAX_IMPORTED_HERMES_MEDIA_BYTES = 100 * 1024 * 1024;
+var MESSAGE_COLUMNS = [
+  "id",
+  "session_id",
+  "role",
+  "content",
+  "tool_call_id",
+  "tool_calls",
+  "tool_name",
+  "timestamp",
+  "token_count",
+  "finish_reason",
+  "reasoning",
+  "reasoning_content",
+  "reasoning_details",
+  "codex_reasoning_items"
+];
+async function syncHermesSessionsIntoConversations(paths, logger, options = {}) {
+  const maxImports = options.maxImports ?? MAX_IMPORTABLE_SESSIONS;
+  const store = new ConversationStore(paths);
+  const knownHermesSessions = await readKnownHermesSessions(store);
+  const profileNames = await discoverHermesProfileNames();
+  const result = {
+    scanned_profiles: profileNames.length,
+    scanned_sessions: 0,
+    eligible_sessions: 0,
+    imported_count: 0,
+    reprojected_count: 0,
+    skipped_existing: 0,
+    skipped_hidden: 0,
+    skipped_deleted: 0,
+    skipped_over_limit: 0,
+    errors: []
+  };
+  const candidates = [];
+  for (const profileName of profileNames) {
+    const profileDir = resolveHermesProfileDir(profileName);
+    const dbPath = path14.join(profileDir, "state.db");
+    const sessions = await listProfileSessions(dbPath).catch((error) => {
+      result.errors.push({
+        profile: profileName,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    });
+    result.scanned_sessions += sessions.length;
+    for (const session of sessions) {
+      if (isDeletedSession(session)) {
+        result.skipped_deleted += 1;
+        continue;
+      }
+      if (isHiddenSession(session)) {
+        result.skipped_hidden += 1;
+        continue;
+      }
+      result.eligible_sessions += 1;
+      candidates.push({ profileName, profileDir, dbPath, session });
+    }
   }
-  return await readJsonResponse(response);
-}
-async function listHermesCronJobs(options = {}) {
-  const query = options.includeDisabled ? "?include_disabled=true" : "";
-  const response = await callHermesApi(
-    `/api/jobs${query}`,
-    { method: "GET" },
-    options
-  );
-  const payload = await readJsonResponse(response);
-  const jobs = payload.jobs;
-  return Array.isArray(jobs) ? jobs.filter(isRecord).map((job) => ({ ...job })) : [];
+  candidates.sort((left, right) => {
+    const rightTime = readNumber2(right.session.last_active) ?? 0;
+    const leftTime = readNumber2(left.session.last_active) ?? 0;
+    return rightTime - leftTime;
+  });
+  const importableCandidates = candidates.slice(0, maxImports);
+  result.skipped_over_limit = Math.max(0, candidates.length - maxImports);
+  for (const candidate of importableCandidates) {
+    if (knownHermesSessions.ids.has(candidate.session.id)) {
+      result.skipped_existing += 1;
+      const reprojected = await reprojectExistingHermesConversation({
+        paths,
+        store,
+        logger,
+        candidate,
+        conversationIds: knownHermesSessions.conversationIdsBySessionId.get(
+          candidate.session.id
+        ) ?? []
+      }).catch((error) => {
+        result.errors.push({
+          profile: candidate.profileName,
+          message: error instanceof Error ? error.message : String(error)
+        });
+        return false;
+      });
+      if (reprojected) {
+        result.reprojected_count += 1;
+      }
+      continue;
+    }
+    const imported = await importHermesSession({
+      paths,
+      store,
+      logger,
+      candidate,
+      existingHermesSessionIds: knownHermesSessions.ids
+    }).catch((error) => {
+      result.errors.push({
+        profile: candidate.profileName,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    });
+    if (imported) {
+      result.imported_count += 1;
+    }
+  }
+  if (result.imported_count > 0 || result.reprojected_count > 0 || result.errors.length > 0) {
+    void logger.info("hermes_session_sync_completed", { ...result });
+  } else {
+    void logger.debug("hermes_session_sync_completed", { ...result });
+  }
+  return result;
 }
-async function getHermesCronJob(jobId, options = {}) {
-  const response = await callHermesApi(
-    `/api/jobs/${encodeURIComponent(jobId)}`,
-    { method: "GET" },
-    options
+async function importHermesSession(input) {
+  const { paths, store, logger, candidate, existingHermesSessionIds } = input;
+  const profile = await resolveConversationProfileTarget(
+    paths,
+    candidate.profileName
   );
-  const payload = await readJsonResponse(response);
-  if (!isRecord(payload.job)) {
-    throw new LinkHttpError(
-      502,
-      "hermes_cron_job_invalid",
-      "Hermes API Server did not return a cron job"
-    );
+  const sessionId = candidate.session.id;
+  const messages = await readHermesSessionMessages(candidate);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const createdAt = isoFromHermesTime(candidate.session.started_at) ?? now;
+  const updatedAt = isoFromHermesTime(candidate.session.last_active) ?? isoFromHermesTime(messages.at(-1)?.timestamp) ?? createdAt;
+  const conversationId = createConversationId();
+  const snapshot = {
+    schema_version: 1,
+    messages: toLinkMessages({
+      conversationId,
+      profileName: profile.profileName,
+      profileUid: profile.profileUid,
+      profileDisplayName: profile.profileDisplayName,
+      sessionId,
+      messages
+    }),
+    runs: []
+  };
+  const title = readString9(candidate.session, "title") ?? firstUserText(snapshot);
+  const manifest = {
+    id: conversationId,
+    schema_version: 1,
+    kind: "direct",
+    title: normalizeTitle(title),
+    title_source: title ? "hermes" : "default",
+    status: "active",
+    hermes_session_id: sessionId,
+    hermes_session_ids: [sessionId],
+    profile_uid: profile.profileUid,
+    profile_name_snapshot: profile.profileName,
+    profile: profile.profileName,
+    created_at: createdAt,
+    updated_at: updatedAt,
+    last_event_seq: 0
+  };
+  await store.createConversation(manifest, snapshot);
+  await hydrateImportedConversationMedia({
+    paths,
+    store,
+    logger,
+    conversationId
+  });
+  const hydratedSnapshot = await store.readSnapshot(conversationId);
+  await store.appendEvent(conversationId, {
+    type: "conversation.created",
+    payload: {
+      imported_from: "hermes",
+      hermes_session_id: sessionId,
+      profile: {
+        uid: profile.profileUid,
+        name: profile.profileName,
+        display_name: profile.profileDisplayName,
+        avatar_url: profile.profileAvatarUrl
+      }
+    }
+  });
+  for (const message of hydratedSnapshot.messages) {
+    await store.appendEvent(conversationId, {
+      type: "message.created",
+      message_id: message.id,
+      payload: { message, imported_from: "hermes" },
+      raw: message.raw
+    });
   }
-  return { ...payload.job };
-}
-async function createHermesCronJob(input, options = {}) {
-  const response = await callHermesApi(
-    "/api/jobs",
-    {
-      method: "POST",
-      body: JSON.stringify(input),
-      headers: { "content-type": "application/json" }
-    },
-    options
+  const stats = buildConversationStats(
+    await store.readManifest(conversationId),
+    hydratedSnapshot
   );
-  const payload = await readJsonResponse(response);
-  if (!isRecord(payload.job)) {
-    throw new LinkHttpError(
-      502,
-      "hermes_cron_job_invalid",
-      "Hermes API Server did not return a cron job"
+  await store.writeManifest({
+    ...await store.readManifest(conversationId),
+    stats
+  });
+  await upsertConversationStats(
+    paths,
+    toStatsIndexRecord(await store.readManifest(conversationId), stats)
+  );
+  existingHermesSessionIds.add(sessionId);
+  return true;
+}
+async function reprojectExistingHermesConversation(input) {
+  let changed = false;
+  for (const conversationId of input.conversationIds) {
+    const manifest = await input.store.readManifest(conversationId).catch(() => null);
+    if (!manifest || manifest.status !== "active") {
+      continue;
+    }
+    const snapshot = await input.store.readSnapshot(conversationId).catch(() => null);
+    if (!snapshot) {
+      continue;
+    }
+    const prefix = collectImportedHermesPrefix(snapshot);
+    if (!prefix?.needsUpgrade || prefix.messages.length === 0) {
+      continue;
+    }
+    const profile = await resolveConversationProfileTarget(
+      input.paths,
+      manifest.profile_name_snapshot ?? manifest.profile ?? input.candidate.profileName
     );
+    const nextSnapshot = {
+      ...snapshot,
+      messages: [
+        ...toLinkMessages({
+          conversationId,
+          profileName: profile.profileName,
+          profileUid: profile.profileUid,
+          profileDisplayName: profile.profileDisplayName,
+          sessionId: input.candidate.session.id,
+          messages: prefix.messages
+        }),
+        ...snapshot.messages.slice(prefix.endIndex)
+      ]
+    };
+    await input.store.writeSnapshot(conversationId, nextSnapshot);
+    await hydrateImportedConversationMedia({
+      paths: input.paths,
+      store: input.store,
+      logger: input.logger,
+      conversationId
+    });
+    const hydratedSnapshot = await input.store.readSnapshot(conversationId);
+    const stats = buildConversationStats(manifest, hydratedSnapshot);
+    await input.store.writeManifest({ ...manifest, stats });
+    await upsertConversationStats(
+      input.paths,
+      toStatsIndexRecord({ ...manifest, stats }, stats)
+    );
+    changed = true;
   }
-  return { ...payload.job };
+  return changed;
 }
-async function updateHermesCronJob(jobId, input, options = {}) {
-  const response = await callHermesApi(
-    `/api/jobs/${encodeURIComponent(jobId)}`,
-    {
-      method: "PATCH",
-      body: JSON.stringify(input),
-      headers: { "content-type": "application/json" }
-    },
-    options
-  );
-  const payload = await readJsonResponse(response);
-  if (!isRecord(payload.job)) {
-    throw new LinkHttpError(
-      502,
-      "hermes_cron_job_invalid",
-      "Hermes API Server did not return a cron job"
-    );
+function collectImportedHermesPrefix(snapshot) {
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  let needsProjectionVersion = false;
+  let hasToolMetadata = false;
+  let hasMediaDeliveryMarkup = false;
+  let endIndex = 0;
+  for (; endIndex < snapshot.messages.length; endIndex += 1) {
+    const message = snapshot.messages[endIndex];
+    if (!isHermesImportedMessage(message)) {
+      break;
+    }
+    if (message.hermes?.import_projection !== HERMES_IMPORT_PROJECTION_VERSION) {
+      needsProjectionVersion = true;
+    }
+    if (message.role === "tool") {
+      hasToolMetadata = true;
+    }
+    for (const row of readHermesRawMessageRows(message.raw)) {
+      appendHermesRowOnce(rows, seen, row);
+      if (hasHermesToolMetadata(row)) {
+        hasToolMetadata = true;
+      }
+      if (collectMediaTags(normalizeContent(row.content)).length > 0) {
+        hasMediaDeliveryMarkup = true;
+      }
+    }
+    for (const event of message.agent_events ?? []) {
+      for (const row of readHermesRowsFromAgentEvent(event)) {
+        appendHermesRowOnce(rows, seen, row);
+        if (hasHermesToolMetadata(row)) {
+          hasToolMetadata = true;
+        }
+        if (collectMediaTags(normalizeContent(row.content)).length > 0) {
+          hasMediaDeliveryMarkup = true;
+        }
+      }
+    }
   }
-  return { ...payload.job };
+  if (rows.length === 0 || endIndex === 0) {
+    return null;
+  }
+  return {
+    endIndex,
+    messages: rows,
+    needsUpgrade: needsProjectionVersion && (hasToolMetadata || hasMediaDeliveryMarkup)
+  };
 }
-async function deleteHermesCronJob(jobId, options = {}) {
-  const response = await callHermesApi(
-    `/api/jobs/${encodeURIComponent(jobId)}`,
-    { method: "DELETE" },
-    options
-  );
-  await readJsonResponse(response);
+function isHermesImportedMessage(message) {
+  return message.hermes?.imported_from === "hermes" || message.raw?.format === "hermes-message" || message.raw?.format === "hermes-message-group";
 }
-async function runHermesCronJobAction(jobId, action, options = {}) {
-  const response = await callHermesApi(
-    `/api/jobs/${encodeURIComponent(jobId)}/${action}`,
-    { method: "POST" },
-    options
-  );
-  const payload = await readJsonResponse(response);
-  if (!isRecord(payload.job)) {
-    throw new LinkHttpError(
-      502,
-      "hermes_cron_job_invalid",
-      "Hermes API Server did not return a cron job"
-    );
+function readHermesRowsFromAgentEvent(event) {
+  if (event.raw?.format !== "hermes-message" && event.raw?.format !== "hermes-message-group") {
+    return [];
   }
-  return { ...payload.job };
-}
-async function createHermesRun(input, options = {}) {
-  const response = await callHermesApi(
-    "/v1/runs",
-    {
-      method: "POST",
-      body: JSON.stringify(input),
-      headers: { "content-type": "application/json" }
-    },
-    options
+  const payload = toRecord8(event.raw.payload);
+  const message = toRecord8(payload.message);
+  if (normalizeMessageRole(readString9(message, "role") ?? void 0) === "tool") {
+    return [message];
+  }
+  return readHermesRawMessageRows(event.raw).filter(
+    (row) => Boolean(readString9(row, "role"))
   );
-  if (response.status === 404 || response.status === 503) {
-    assertHermesRunsApiSupported(
-      await readHermesVersion().catch(() => null),
-      response.status
-    );
-    throw new LinkHttpError(
-      503,
-      "hermes_api_server_unavailable",
-      "Hermes API Server is unavailable"
-    );
+}
+function appendHermesRowOnce(rows, seen, row) {
+  const key = hermesRowKey(row, rows.length);
+  if (seen.has(key)) {
+    return;
   }
-  const payload = await readJsonResponse(response);
-  const runId = readString9(payload, "run_id") ?? readString9(payload, "runId") ?? readString9(payload, "id");
-  if (!runId) {
-    throw new LinkHttpError(
-      502,
-      "hermes_run_invalid",
-      "Hermes API Server did not return a run id"
-    );
+  seen.add(key);
+  rows.push(row);
+}
+function hermesRowKey(row, fallbackIndex) {
+  if (row.id !== void 0 && row.id !== null) {
+    return `id:${row.id}`;
   }
-  return { run_id: runId, fallback: false };
+  return `fallback:${fallbackIndex}:${row.role ?? ""}:${row.timestamp ?? ""}:${normalizeContent(row.content)}`;
 }
-async function streamHermesRunEvents(runId, options = {}) {
-  const response = await callHermesApi(
-    `/v1/runs/${encodeURIComponent(runId)}/events`,
-    { method: "GET", signal: options.signal },
-    options
+function hasHermesToolMetadata(row) {
+  return normalizeMessageRole(row.role) === "tool" || readHermesToolCalls(row).length > 0 || Boolean(readString9(row, "tool_call_id")) || Boolean(readString9(row, "tool_name"));
+}
+function toLinkMessages(input) {
+  const linkMessages = [];
+  let pendingToolCalls = [];
+  const toolCallsById = /* @__PURE__ */ new Map();
+  let currentAssistant = null;
+  const finishAssistantTurn = () => {
+    if (!currentAssistant) {
+      return;
+    }
+    pendingToolCalls.forEach((pending, index) => {
+      const event = projectHermesToolCallWithoutOutputEvent({
+        conversationId: input.conversationId,
+        messageId: pending.message.id,
+        pending,
+        index
+      });
+      if (event) {
+        attachAgentEventToMessage(pending.message, event, event.created_at);
+      }
+    });
+    pendingToolCalls = [];
+    toolCallsById.clear();
+    currentAssistant = null;
+  };
+  input.messages.forEach((message, index) => {
+    const role = normalizeMessageRole(message.role);
+    if (role === "tool") {
+      const pending = consumePendingToolCall({
+        toolMessage: message,
+        pendingToolCalls,
+        toolCallsById
+      });
+      let target = pending?.message ?? currentAssistant;
+      let createdSynthetic = false;
+      if (!target) {
+        target = createSyntheticToolAssistantMessage({
+          ...input,
+          message,
+          index
+        });
+        linkMessages.push(target);
+        currentAssistant = target;
+        createdSynthetic = true;
+      }
+      if (!createdSynthetic) {
+        appendHermesRawMessage(target, message);
+        rememberHermesMessageId(target, message);
+      }
+      const event = projectHermesToolCompletedEvent({
+        conversationId: input.conversationId,
+        messageId: target.id,
+        sourceMessage: message,
+        pending,
+        index
+      });
+      if (event) {
+        attachAgentEventToMessage(target, event, event.created_at);
+      }
+      return;
+    }
+    if (role === "assistant") {
+      if (!currentAssistant) {
+        currentAssistant = toLinkMessage({
+          conversationId: input.conversationId,
+          profileName: input.profileName,
+          profileUid: input.profileUid,
+          profileDisplayName: input.profileDisplayName,
+          sessionId: input.sessionId,
+          message,
+          index
+        });
+        linkMessages.push(currentAssistant);
+      } else {
+        appendHermesRawMessage(currentAssistant, message);
+        rememberHermesMessageId(currentAssistant, message);
+        appendAssistantTextToMessage({
+          message: currentAssistant,
+          text: normalizeContent(message.content),
+          updatedAt: isoFromHermesTime(message.timestamp) ?? currentAssistant.updated_at
+        });
+      }
+      for (const toolCall of readHermesToolCalls(message)) {
+        const pending = { message: currentAssistant, toolCall };
+        pendingToolCalls.push(pending);
+        if (toolCall.id) {
+          toolCallsById.set(toolCall.id, pending);
+        }
+        const event = projectHermesToolStartedEvent({
+          conversationId: input.conversationId,
+          messageId: currentAssistant.id,
+          sourceMessage: message,
+          toolCall,
+          index
+        });
+        if (event) {
+          attachAgentEventToMessage(currentAssistant, event, event.created_at);
+        }
+      }
+      return;
+    }
+    finishAssistantTurn();
+    const linkMessage = toLinkMessage({
+      conversationId: input.conversationId,
+      profileName: input.profileName,
+      profileUid: input.profileUid,
+      profileDisplayName: input.profileDisplayName,
+      sessionId: input.sessionId,
+      message,
+      index
+    });
+    linkMessages.push(linkMessage);
+  });
+  finishAssistantTurn();
+  return linkMessages;
+}
+function consumePendingToolCall(input) {
+  const toolCallId = readString9(input.toolMessage, "tool_call_id");
+  const toolName = readString9(input.toolMessage, "tool_name");
+  let pending = toolCallId ? input.toolCallsById.get(toolCallId) : void 0;
+  if (!pending && toolName) {
+    pending = input.pendingToolCalls.find(
+      (item) => item.toolCall.name === toolName
+    );
+  }
+  if (!pending && !toolCallId) {
+    pending = input.pendingToolCalls[0];
+  }
+  if (!pending) {
+    return void 0;
+  }
+  const index = input.pendingToolCalls.indexOf(pending);
+  if (index >= 0) {
+    input.pendingToolCalls.splice(index, 1);
+  }
+  if (pending.toolCall.id) {
+    input.toolCallsById.delete(pending.toolCall.id);
+  }
+  return pending;
+}
+function createSyntheticToolAssistantMessage(input) {
+  const message = toLinkMessage({
+    conversationId: input.conversationId,
+    profileName: input.profileName,
+    profileUid: input.profileUid,
+    profileDisplayName: input.profileDisplayName,
+    sessionId: input.sessionId,
+    message: {
+      ...input.message,
+      role: "assistant",
+      content: null
+    },
+    index: input.index
+  });
+  message.raw = {
+    format: "hermes-message",
+    payload: input.message
+  };
+  return message;
+}
+function readHermesToolCalls(message) {
+  const decoded = parseJsonValue(message.tool_calls) ?? message.tool_calls;
+  const values = Array.isArray(decoded) ? decoded : decoded ? [decoded] : [];
+  return values.map((value) => normalizeHermesToolCall(value)).filter(
+    (toolCall) => Boolean(toolCall)
+  );
+}
+function normalizeHermesToolCall(value) {
+  const record = toRecord8(value);
+  if (Object.keys(record).length === 0) {
+    return null;
+  }
+  const fn = toRecord8(record.function);
+  const id = readString9(record, "id") ?? readString9(record, "call_id") ?? readString9(record, "tool_call_id") ?? readString9(fn, "id") ?? void 0;
+  const name = readString9(fn, "name") ?? readString9(record, "name") ?? readString9(record, "tool_name") ?? readString9(record, "tool") ?? "tool";
+  const rawArguments = fn.arguments ?? record.arguments ?? record.args ?? record.input;
+  return {
+    ...id ? { id } : {},
+    name,
+    ...rawArguments === void 0 ? {} : { arguments: parseJsonValue(rawArguments) ?? rawArguments },
+    raw: value
+  };
+}
+function projectHermesToolStartedEvent(input) {
+  const createdAt = isoFromHermesTime(input.sourceMessage.timestamp) ?? new Date(Date.now() + input.index).toISOString();
+  return projectHermesAgentEvent({
+    conversationId: input.conversationId,
+    messageId: input.messageId,
+    type: "tool.started",
+    createdAt,
+    seq: input.index + 1,
+    payload: {
+      type: "tool.started",
+      tool: input.toolCall.name,
+      tool_name: input.toolCall.name,
+      name: input.toolCall.name,
+      ...input.toolCall.id ? { tool_call_id: input.toolCall.id, id: input.toolCall.id } : {},
+      ...input.toolCall.arguments === void 0 ? {} : { arguments: input.toolCall.arguments },
+      tool_call: input.toolCall.raw
+    },
+    raw: {
+      format: "hermes-message",
+      payload: {
+        message: input.sourceMessage,
+        tool_call: input.toolCall.raw
+      }
+    }
+  });
+}
+function projectHermesToolCompletedEvent(input) {
+  const createdAt = isoFromHermesTime(input.sourceMessage.timestamp) ?? new Date(Date.now() + input.index).toISOString();
+  const output = normalizeContent(input.sourceMessage.content);
+  const parsedOutput = parseJsonValue(output);
+  const toolCallId = readString9(input.sourceMessage, "tool_call_id") ?? input.pending?.toolCall.id;
+  const toolName = readString9(input.sourceMessage, "tool_name") ?? input.pending?.toolCall.name ?? "tool";
+  return projectHermesAgentEvent({
+    conversationId: input.conversationId,
+    messageId: input.messageId,
+    type: "tool.completed",
+    createdAt,
+    seq: input.index + 1,
+    payload: {
+      type: "tool.completed",
+      tool: toolName,
+      tool_name: toolName,
+      name: toolName,
+      ...toolCallId ? { tool_call_id: toolCallId, id: toolCallId } : {},
+      ...input.pending?.toolCall.arguments === void 0 ? {} : { arguments: input.pending.toolCall.arguments },
+      output,
+      content: output,
+      result: parsedOutput ?? output,
+      ...input.pending ? { tool_call: input.pending.toolCall.raw } : {}
+    },
+    raw: {
+      format: "hermes-message",
+      payload: {
+        message: input.sourceMessage,
+        ...input.pending ? { tool_call: input.pending.toolCall.raw } : {}
+      }
+    }
+  });
+}
+function projectHermesToolCallWithoutOutputEvent(input) {
+  return projectHermesAgentEvent({
+    conversationId: input.conversationId,
+    messageId: input.messageId,
+    type: "tool.completed",
+    createdAt: input.pending.message.updated_at,
+    seq: input.index + 1,
+    payload: {
+      type: "tool.completed",
+      tool: input.pending.toolCall.name,
+      tool_name: input.pending.toolCall.name,
+      name: input.pending.toolCall.name,
+      ...input.pending.toolCall.id ? {
+        tool_call_id: input.pending.toolCall.id,
+        id: input.pending.toolCall.id
+      } : {},
+      ...input.pending.toolCall.arguments === void 0 ? {} : { arguments: input.pending.toolCall.arguments },
+      tool_call: input.pending.toolCall.raw
+    },
+    raw: {
+      format: "hermes-tool-call",
+      payload: {
+        tool_call: input.pending.toolCall.raw,
+        note: "tool_output_not_found"
+      }
+    }
+  });
+}
+function projectHermesAgentEvent(input) {
+  const event = {
+    seq: input.seq,
+    type: input.type,
+    conversation_id: input.conversationId,
+    message_id: input.messageId,
+    created_at: input.createdAt,
+    payload: input.payload,
+    raw: input.raw
+  };
+  return projectConversationAgentEvent(event);
+}
+function attachAgentEventToMessage(message, event, updatedAt) {
+  ensureTextBlockForMessage(message);
+  message.agent_events = upsertAgentEventProjection(
+    message.agent_events ?? [],
+    event
+  );
+  appendAgentEventBlock(message, event, updatedAt);
+  message.updated_at = latestTimestamp(message.updated_at, updatedAt);
+}
+function appendAssistantTextToMessage(input) {
+  const text = input.text;
+  if (!text) {
+    return;
+  }
+  appendTextPart(input.message, text);
+  if (input.message.blocks?.length) {
+    appendTextBlock(input.message, text, input.updatedAt);
+  }
+  input.message.updated_at = latestTimestamp(
+    input.message.updated_at,
+    input.updatedAt
+  );
+}
+function appendTextPart(message, text) {
+  const existing = message.parts.find((part) => part.type === "text");
+  if (existing) {
+    existing.text = joinImportedText(existing.text ?? "", text);
+    return;
+  }
+  message.parts.push({ type: "text", text });
+}
+function appendTextBlock(message, text, updatedAt) {
+  const blocks = [...message.blocks ?? []];
+  const last = blocks.at(-1);
+  if (last?.type === "text") {
+    blocks[blocks.length - 1] = {
+      ...last,
+      text: joinImportedText(last.text, text),
+      updated_at: updatedAt
+    };
+  } else {
+    blocks.push({
+      id: `text_${blocks.length + 1}`,
+      type: "text",
+      text,
+      created_at: updatedAt,
+      updated_at: updatedAt
+    });
+  }
+  message.blocks = blocks;
+}
+function ensureTextBlockForMessage(message) {
+  if (message.blocks?.length) {
+    return;
+  }
+  const text = message.parts.filter((part) => part.type === "text" && part.text).map((part) => part.text).join("");
+  if (!text) {
+    return;
+  }
+  message.blocks = [
+    {
+      id: "text_1",
+      type: "text",
+      text,
+      created_at: message.created_at,
+      updated_at: message.updated_at
+    }
+  ];
+}
+function appendAgentEventBlock(message, event, updatedAt) {
+  const blocks = [...message.blocks ?? []];
+  const matchingIndex = blocks.findIndex((block) => {
+    if (block.type !== "agent_events") {
+      return false;
+    }
+    return upsertAgentEventProjection(block.events, event).length === block.events.length;
+  });
+  const targetIndex = matchingIndex >= 0 ? matchingIndex : blocks.at(-1)?.type === "agent_events" ? blocks.length - 1 : -1;
+  if (targetIndex >= 0) {
+    const block = blocks[targetIndex];
+    if (block.type === "agent_events") {
+      blocks[targetIndex] = {
+        ...block,
+        events: upsertAgentEventProjection(block.events, event),
+        updated_at: updatedAt
+      };
+    }
+  } else {
+    blocks.push({
+      id: `tools_${blocks.length + 1}`,
+      type: "agent_events",
+      events: [event],
+      created_at: updatedAt,
+      updated_at: updatedAt
+    });
+  }
+  message.blocks = blocks;
+}
+function latestTimestamp(left, right) {
+  const leftTime = Date.parse(left);
+  const rightTime = Date.parse(right);
+  if (Number.isNaN(leftTime)) {
+    return right;
+  }
+  if (Number.isNaN(rightTime)) {
+    return left;
+  }
+  return leftTime >= rightTime ? left : right;
+}
+async function readKnownHermesSessions(store) {
+  const ids = /* @__PURE__ */ new Set();
+  const conversationIdsBySessionId = /* @__PURE__ */ new Map();
+  for (const conversationId of await store.listConversationIds()) {
+    const manifest = await store.readManifest(conversationId).catch(() => null);
+    if (!manifest) {
+      continue;
+    }
+    if (manifest.hermes_session_id) {
+      ids.add(manifest.hermes_session_id);
+      rememberKnownHermesConversation(
+        conversationIdsBySessionId,
+        manifest.hermes_session_id,
+        conversationId
+      );
+    }
+    for (const sessionId of manifest.hermes_session_ids ?? []) {
+      ids.add(sessionId);
+      rememberKnownHermesConversation(
+        conversationIdsBySessionId,
+        sessionId,
+        conversationId
+      );
+    }
+  }
+  return { ids, conversationIdsBySessionId };
+}
+function rememberKnownHermesConversation(map, sessionId, conversationId) {
+  const current = map.get(sessionId) ?? [];
+  if (!current.includes(conversationId)) {
+    map.set(sessionId, [...current, conversationId]);
+  }
+}
+async function discoverHermesProfileNames() {
+  const names = /* @__PURE__ */ new Set([DEFAULT_PROFILE_NAME]);
+  const profilesDir = path14.join(os4.homedir(), ".hermes", "profiles");
+  const entries = await readdir6(profilesDir, { withFileTypes: true }).catch(
+    (error) => {
+      if (isNodeError10(error, "ENOENT")) {
+        return [];
+      }
+      throw error;
+    }
+  );
+  for (const entry of entries) {
+    if (entry.isDirectory() && PROFILE_NAME_PATTERN3.test(entry.name)) {
+      names.add(entry.name);
+    }
+  }
+  return [...names].sort((left, right) => {
+    if (left === DEFAULT_PROFILE_NAME) {
+      return -1;
+    }
+    if (right === DEFAULT_PROFILE_NAME) {
+      return 1;
+    }
+    return left.localeCompare(right);
+  });
+}
+async function listProfileSessions(dbPath) {
+  if (!await isFile(dbPath)) {
+    return [];
+  }
+  let db = null;
+  try {
+    const { DatabaseSync } = nodeRequire3(
+      "node:sqlite"
+    );
+    db = new DatabaseSync(dbPath, {
+      readOnly: true,
+      timeout: 1e3
+    });
+    const sessionColumns = readTableColumns(db, "sessions");
+    if (!sessionColumns.has("id")) {
+      return [];
+    }
+    const messageColumns = readTableColumns(db, "messages");
+    const selectColumns = [...sessionColumns].map((column) => `s.${quoteIdentifier(column)}`).join(", ");
+    const lastActiveSql = messageColumns.has("timestamp") ? `COALESCE(
+          (SELECT MAX(m.timestamp) FROM messages m WHERE m.session_id = s.id),
+          s.started_at,
+          0
+        ) AS last_active` : "COALESCE(s.started_at, 0) AS last_active";
+    const rows = db.prepare(
+      `
+        SELECT ${selectColumns}, ${lastActiveSql}
+        FROM sessions s
+        ORDER BY last_active DESC
+      `
+    ).all();
+    return projectCompressionTips(rows);
+  } finally {
+    db?.close();
+  }
+}
+function appendHermesRawMessage(message, row) {
+  const rows = readHermesRawMessageRows(message.raw);
+  message.raw = rows.length === 0 ? {
+    format: "hermes-message",
+    payload: row
+  } : {
+    format: "hermes-message-group",
+    payload: { messages: [...rows, row] }
+  };
+}
+function readHermesRawMessageRows(raw) {
+  if (!raw) {
+    return [];
+  }
+  if (raw.format === "hermes-message-group") {
+    const payload = toRecord8(raw.payload);
+    return Array.isArray(payload.messages) ? payload.messages.filter(
+      (item) => typeof item === "object" && item !== null
+    ) : [];
+  }
+  if (raw.format === "hermes-message") {
+    return typeof raw.payload === "object" && raw.payload !== null ? [raw.payload] : [];
+  }
+  return [];
+}
+function rememberHermesMessageId(message, row) {
+  if (row.id === void 0 || row.id === null) {
+    return;
+  }
+  const existing = Array.isArray(message.hermes?.message_ids) ? message.hermes.message_ids : message.hermes?.message_id === void 0 ? [] : [message.hermes.message_id];
+  const id = row.id;
+  message.hermes = {
+    ...message.hermes ?? {},
+    message_ids: existing.includes(id) ? existing : [...existing, id]
+  };
+}
+function joinImportedText(left, right) {
+  if (!left) {
+    return right;
+  }
+  if (!right) {
+    return left;
+  }
+  if (/\s$/u.test(left) || /^\s/u.test(right)) {
+    return `${left}${right}`;
+  }
+  return `${left}
+
+${right}`;
+}
+function projectCompressionTips(rows) {
+  const byId = /* @__PURE__ */ new Map();
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const id = readString9(row, "id");
+    if (!id) {
+      continue;
+    }
+    byId.set(id, row);
+    const parentId = readString9(row, "parent_session_id");
+    if (parentId) {
+      const children = childrenByParent.get(parentId) ?? [];
+      children.push(row);
+      childrenByParent.set(parentId, children);
+    }
+  }
+  const projected = [];
+  for (const row of rows) {
+    const id = readString9(row, "id");
+    if (!id || readString9(row, "parent_session_id")) {
+      continue;
+    }
+    let tip = row;
+    const visited = /* @__PURE__ */ new Set([id]);
+    while (readString9(tip, "end_reason") === "compression") {
+      const tipId2 = readString9(tip, "id");
+      if (!tipId2) {
+        break;
+      }
+      const next = (childrenByParent.get(tipId2) ?? []).filter((child) => readString9(child, "id")).sort(
+        (left, right) => (readNumber2(right.last_active) ?? 0) - (readNumber2(left.last_active) ?? 0)
+      )[0];
+      const nextId = next ? readString9(next, "id") : null;
+      if (!next || !nextId || visited.has(nextId)) {
+        break;
+      }
+      tip = next;
+      visited.add(nextId);
+    }
+    const tipId = readString9(tip, "id");
+    if (tipId) {
+      projected.push({
+        ...tip,
+        id: tipId,
+        _lineage_root_id: id,
+        started_at: readNumber2(row.started_at) ?? readNumber2(tip.started_at)
+      });
+    }
+  }
+  return projected;
+}
+async function readHermesSessionMessages(candidate) {
+  const [dbMessages, jsonlMessages] = await Promise.all([
+    readStateDbMessages(candidate.dbPath, candidate.session.id),
+    readJsonlMessages(candidate.profileName, candidate.session.id)
+  ]);
+  return jsonlMessages.length > dbMessages.length ? jsonlMessages : dbMessages;
+}
+async function readStateDbMessages(dbPath, sessionId) {
+  if (!await isFile(dbPath)) {
+    return [];
+  }
+  let db = null;
+  try {
+    const { DatabaseSync } = nodeRequire3(
+      "node:sqlite"
+    );
+    db = new DatabaseSync(dbPath, {
+      readOnly: true,
+      timeout: 1e3
+    });
+    const columns = readTableColumns(db, "messages");
+    if (!columns.has("session_id") || !columns.has("role")) {
+      return [];
+    }
+    const selectColumns = MESSAGE_COLUMNS.map(
+      (column) => columns.has(column) ? quoteIdentifier(column) : `NULL AS ${column}`
+    ).join(", ");
+    return db.prepare(
+      `
+        SELECT ${selectColumns}
+        FROM messages
+        WHERE session_id = ?
+        ORDER BY timestamp, id
+      `
+    ).all(sessionId);
+  } catch {
+    return [];
+  } finally {
+    db?.close();
+  }
+}
+async function readJsonlMessages(profileName, sessionId) {
+  if (!/^[A-Za-z0-9._:-]{1,160}$/u.test(sessionId)) {
+    return [];
+  }
+  const profileDir = resolveHermesProfileDir(profileName);
+  const sessionsDir = await readHermesSessionsDir(profileName).then((value) => value.sessionsDir).catch(() => path14.join(profileDir, "sessions"));
+  const transcriptPath = path14.join(sessionsDir, `${sessionId}.jsonl`);
+  const raw = await readFile9(transcriptPath, "utf8").catch((error) => {
+    if (isNodeError10(error, "ENOENT")) {
+      return "";
+    }
+    throw error;
+  });
+  if (!raw.trim()) {
+    return [];
+  }
+  const rows = [];
+  for (const line of raw.split(/\r?\n/u)) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(line);
+      const normalized = normalizeJsonlMessage(parsed);
+      if (normalized) {
+        rows.push(normalized);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return rows;
+}
+function normalizeJsonlMessage(row) {
+  const role = readString9(row, "role");
+  if (!role) {
+    return null;
+  }
+  const content = normalizeContent(row.content);
+  const timestamp = readNumber2(row.timestamp) ?? readNumber2(row.created_at) ?? readNumber2(row.createdAt);
+  return {
+    ...row,
+    role,
+    content,
+    timestamp: timestamp ?? void 0
+  };
+}
+async function hydrateImportedConversationMedia(input) {
+  const snapshot = await input.store.readSnapshot(input.conversationId);
+  const imports = snapshot.messages.map((message) => ({
+    messageId: message.id,
+    references: collectMessageMediaReferences(message)
+  })).filter((item) => item.references.length > 0);
+  if (imports.length === 0) {
+    return;
+  }
+  const outcomes = /* @__PURE__ */ new Map();
+  for (const item of imports) {
+    const result = await importMediaReferencesForMessage(
+      {
+        logger: input.logger,
+        readSnapshot: (conversationId) => input.store.readSnapshot(conversationId),
+        writeSnapshot: (conversationId, nextSnapshot2) => input.store.writeSnapshot(conversationId, nextSnapshot2),
+        appendEvent: async (conversationId, event) => ({
+          seq: 0,
+          conversation_id: conversationId,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          ...event
+        }),
+        writeBlob: (conversationId, blob) => writeConversationBlob(input.paths, conversationId, blob, {
+          maxBytes: MAX_IMPORTED_HERMES_MEDIA_BYTES
+        })
+      },
+      {
+        conversationId: input.conversationId,
+        runId: IMPORTED_MEDIA_PLACEHOLDER_RUN_ID,
+        messageId: item.messageId,
+        references: item.references
+      }
+    );
+    if (result.imported_count > 0 || result.failed_count > 0) {
+      outcomes.set(item.messageId, {
+        imported: result.imported_count > 0,
+        failed: result.failed_count > 0
+      });
+    }
+  }
+  if (outcomes.size === 0) {
+    return;
+  }
+  const nextSnapshot = await input.store.readSnapshot(input.conversationId);
+  let changed = false;
+  for (const message of nextSnapshot.messages) {
+    const outcome = outcomes.get(message.id);
+    if (!outcome) {
+      continue;
+    }
+    if (outcome.imported) {
+      cleanMessageTextParts(message);
+      changed = true;
+    }
+    if (outcome.failed) {
+      changed = appendImportedMediaImportFailureNotice(message) || changed;
+    }
+  }
+  if (changed) {
+    await input.store.writeSnapshot(input.conversationId, nextSnapshot);
+  }
+}
+function collectMessageMediaReferences(message) {
+  return message.parts.flatMap(
+    (part) => part.type === "text" && part.text ? collectMediaTags(part.text) : []
+  );
+}
+function appendImportedMediaImportFailureNotice(message) {
+  const hermes = toRecord8(message.hermes);
+  if (hermes.media_import_failure_notice_appended === true) {
+    return false;
+  }
+  const failures = readMediaImportFailures(message);
+  if (failures.length === 0) {
+    return false;
+  }
+  const notice = formatImportedMediaImportFailureNotice(failures);
+  const textPart = message.parts.find((part) => part.type === "text");
+  if (textPart) {
+    const currentText = textPart.text ?? "";
+    const separator = currentText.trim().length > 0 ? "\n\n" : "";
+    textPart.text = `${currentText.trimEnd()}${separator}${notice}`;
+  } else {
+    message.parts.unshift({ type: "text", text: notice });
+  }
+  message.hermes = {
+    ...hermes,
+    media_import_failure_notice_appended: true
+  };
+  return true;
+}
+function formatImportedMediaImportFailureNotice(failures) {
+  const filenames = failures.map((failure) => failure.filename);
+  const target = filenames.length === 1 ? `\u6587\u4EF6\u201C${filenames[0]}\u201D` : `${filenames.length} \u4E2A\u6587\u4EF6\uFF08${formatImportedFilenameList(filenames)}\uFF09`;
+  const permissionDenied = failures.some((failure) => {
+    const code = failure.code?.toUpperCase();
+    return code === "EPERM" || code === "EACCES" || /operation not permitted|permission denied/iu.test(failure.reason);
+  });
+  if (permissionDenied) {
+    return `${target}\u6CA1\u80FD\u4F5C\u4E3A\u9644\u4EF6\u5BFC\u5165\uFF1AHermes Link \u8BFB\u53D6\u6587\u4EF6\u65F6\u88AB macOS \u62D2\u7EDD\u4E86\u3002\u8BF7\u5728\u201C\u7CFB\u7EDF\u8BBE\u7F6E > \u9690\u79C1\u4E0E\u5B89\u5168\u6027 > \u5B8C\u5168\u78C1\u76D8\u8BBF\u95EE\u6743\u9650\u201D\u91CC\u7ED9\u8FD0\u884C Link \u7684\u7EC8\u7AEF\u6216 Node \u6388\u6743\u540E\u91CD\u8BD5\u3002`;
+  }
+  return `${target}\u6CA1\u80FD\u4F5C\u4E3A\u9644\u4EF6\u5BFC\u5165\uFF1AHermes Link \u8BFB\u53D6\u672C\u673A\u6587\u4EF6\u5931\u8D25\u4E86\uFF0C\u8BF7\u786E\u8BA4\u6587\u4EF6\u8FD8\u5728\u539F\u4F4D\u7F6E\u5E76\u7A0D\u540E\u91CD\u8BD5\u3002`;
+}
+function formatImportedFilenameList(filenames) {
+  const preview = filenames.slice(0, 3).map((filename) => `\u201C${filename}\u201D`);
+  const remaining = filenames.length - preview.length;
+  return remaining > 0 ? `${preview.join("\u3001")} \u7B49 ${filenames.length} \u4E2A` : preview.join("\u3001");
+}
+function toLinkMessage(input) {
+  const role = normalizeMessageRole(input.message.role);
+  const text = normalizeContent(input.message.content);
+  const createdAt = isoFromHermesTime(input.message.timestamp) ?? new Date(Date.now() + input.index).toISOString();
+  return {
+    id: `msg_${randomUUID6().replaceAll("-", "")}`,
+    schema_version: 1,
+    conversation_id: input.conversationId,
+    role,
+    status: "completed",
+    created_at: createdAt,
+    updated_at: createdAt,
+    sender: senderForRole({
+      role,
+      profileName: input.profileName,
+      profileUid: input.profileUid,
+      profileDisplayName: input.profileDisplayName
+    }),
+    parts: text ? [{ type: "text", text }] : [],
+    attachments: [],
+    hermes: {
+      session_id: input.sessionId,
+      message_id: input.message.id,
+      imported_from: "hermes",
+      import_projection: HERMES_IMPORT_PROJECTION_VERSION
+    },
+    raw: {
+      format: "hermes-message",
+      payload: input.message
+    }
+  };
+}
+function senderForRole(input) {
+  switch (input.role) {
+    case "user":
+      return { id: "hermes_user", type: "human", display_name: "Me" };
+    case "assistant":
+      return {
+        id: `agent_${input.profileName}`,
+        type: "agent",
+        display_name: input.profileDisplayName,
+        profile_uid: input.profileUid,
+        profile: input.profileName
+      };
+    case "tool":
+      return { id: "hermes_tool", type: "tool", display_name: "Tool" };
+    case "system":
+      return { id: "hermes_system", type: "system", display_name: "System" };
+  }
+}
+function firstUserText(snapshot) {
+  return snapshot.messages.find((message) => message.role === "user")?.parts.find((part) => part.type === "text")?.text?.slice(0, 80);
+}
+function normalizeTitle(value) {
+  const normalized = value?.replace(/\s+/gu, " ").trim();
+  return normalized || DEFAULT_CONVERSATION_TITLE;
+}
+function normalizeMessageRole(value) {
+  switch (value?.trim().toLowerCase()) {
+    case "user":
+      return "user";
+    case "assistant":
+      return "assistant";
+    case "tool":
+      return "tool";
+    case "system":
+      return "system";
+    default:
+      return "system";
+  }
+}
+function normalizeContent(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+      if (typeof item === "object" && item !== null) {
+        return readString9(item, "text") ?? "";
+      }
+      return "";
+    }).filter(Boolean).join("");
+  }
+  return "";
+}
+function parseJsonValue(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+}
+function toRecord8(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function isDeletedSession(session) {
+  return readBoolean(session.deleted) || readBoolean(session.is_deleted) || Boolean(readString9(session, "deleted_at")) || ["deleted", "removed"].includes(readString9(session, "status") ?? "");
+}
+function isHiddenSession(session) {
+  const source = readString9(session, "source")?.toLowerCase();
+  const status = readString9(session, "status")?.toLowerCase();
+  const visibility = readString9(session, "visibility")?.toLowerCase();
+  return Boolean(source && HIDDEN_SESSION_SOURCES.has(source)) || readBoolean(session.hidden) || readBoolean(session.archived) || Boolean(readString9(session, "archived_at")) || status === "hidden" || status === "archived" || visibility === "hidden" || visibility === "hide";
+}
+function readTableColumns(db, tableName) {
+  try {
+    const rows = db.prepare(`PRAGMA table_info(${quoteIdentifier(tableName)})`).all();
+    return new Set(
+      rows.map((row) => typeof row.name === "string" ? row.name : "").filter(Boolean)
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function quoteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+async function isFile(filePath) {
+  return stat8(filePath).then((value) => value.isFile()).catch((error) => {
+    if (isNodeError10(error, "ENOENT")) {
+      return false;
+    }
+    throw error;
+  });
+}
+function createConversationId() {
+  return `conv_${randomUUID6().replaceAll("-", "")}`;
+}
+function isoFromHermesTime(value) {
+  const numeric = readNumber2(value);
+  if (!numeric || numeric <= 0) {
+    return void 0;
+  }
+  const millis = numeric > 1e10 ? numeric : numeric * 1e3;
+  return new Date(millis).toISOString();
+}
+function readString9(payload, key) {
+  const value = payload[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function readNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readBoolean(value) {
+  if (value === true || value === 1) {
+    return true;
+  }
+  if (typeof value === "string") {
+    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+  }
+  return false;
+}
+function isNodeError10(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+
+// src/conversations/run-lifecycle.ts
+import { readdir as readdir7 } from "fs/promises";
+
+// src/hermes/api-server.ts
+async function listHermesModels(options = {}) {
+  const response = await callHermesApi("/v1/models", { method: "GET" }, options);
+  if (response.status === 404) {
+    return { models: [] };
+  }
+  return await readJsonResponse(response);
+}
+async function listHermesCronJobs(options = {}) {
+  const query = options.includeDisabled ? "?include_disabled=true" : "";
+  const response = await callHermesApi(
+    `/api/jobs${query}`,
+    { method: "GET" },
+    options
+  );
+  const payload = await readJsonResponse(response);
+  const jobs = payload.jobs;
+  return Array.isArray(jobs) ? jobs.filter(isRecord).map((job) => ({ ...job })) : [];
+}
+async function getHermesCronJob(jobId, options = {}) {
+  const response = await callHermesApi(
+    `/api/jobs/${encodeURIComponent(jobId)}`,
+    { method: "GET" },
+    options
+  );
+  const payload = await readJsonResponse(response);
+  if (!isRecord(payload.job)) {
+    throw new LinkHttpError(
+      502,
+      "hermes_cron_job_invalid",
+      "Hermes API Server did not return a cron job"
+    );
+  }
+  return { ...payload.job };
+}
+async function createHermesCronJob(input, options = {}) {
+  const response = await callHermesApi(
+    "/api/jobs",
+    {
+      method: "POST",
+      body: JSON.stringify(input),
+      headers: { "content-type": "application/json" }
+    },
+    options
+  );
+  const payload = await readJsonResponse(response);
+  if (!isRecord(payload.job)) {
+    throw new LinkHttpError(
+      502,
+      "hermes_cron_job_invalid",
+      "Hermes API Server did not return a cron job"
+    );
+  }
+  return { ...payload.job };
+}
+async function updateHermesCronJob(jobId, input, options = {}) {
+  const response = await callHermesApi(
+    `/api/jobs/${encodeURIComponent(jobId)}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify(input),
+      headers: { "content-type": "application/json" }
+    },
+    options
+  );
+  const payload = await readJsonResponse(response);
+  if (!isRecord(payload.job)) {
+    throw new LinkHttpError(
+      502,
+      "hermes_cron_job_invalid",
+      "Hermes API Server did not return a cron job"
+    );
+  }
+  return { ...payload.job };
+}
+async function deleteHermesCronJob(jobId, options = {}) {
+  const response = await callHermesApi(
+    `/api/jobs/${encodeURIComponent(jobId)}`,
+    { method: "DELETE" },
+    options
+  );
+  await readJsonResponse(response);
+}
+async function runHermesCronJobAction(jobId, action, options = {}) {
+  const response = await callHermesApi(
+    `/api/jobs/${encodeURIComponent(jobId)}/${action}`,
+    { method: "POST" },
+    options
+  );
+  const payload = await readJsonResponse(response);
+  if (!isRecord(payload.job)) {
+    throw new LinkHttpError(
+      502,
+      "hermes_cron_job_invalid",
+      "Hermes API Server did not return a cron job"
+    );
+  }
+  return { ...payload.job };
+}
+async function createHermesRun(input, options = {}) {
+  const response = await callHermesApi(
+    "/v1/runs",
+    {
+      method: "POST",
+      body: JSON.stringify(input),
+      headers: { "content-type": "application/json" }
+    },
+    options
+  );
+  if (response.status === 404 || response.status === 503) {
+    assertHermesRunsApiSupported(
+      await readHermesVersion().catch(() => null),
+      response.status
+    );
+    throw new LinkHttpError(
+      503,
+      "hermes_api_server_unavailable",
+      "Hermes API Server is unavailable"
+    );
+  }
+  const payload = await readJsonResponse(response);
+  const runId = readString10(payload, "run_id") ?? readString10(payload, "runId") ?? readString10(payload, "id");
+  if (!runId) {
+    throw new LinkHttpError(
+      502,
+      "hermes_run_invalid",
+      "Hermes API Server did not return a run id"
+    );
+  }
+  return { run_id: runId, fallback: false };
+}
+async function streamHermesRunEvents(runId, options = {}) {
+  const response = await callHermesApi(
+    `/v1/runs/${encodeURIComponent(runId)}/events`,
+    { method: "GET", signal: options.signal },
+    options
   );
   assertHermesRunsApiSupported(
     await readHermesVersion().catch(() => null),
@@ -9083,10 +10426,10 @@ async function cancelHermesRun(runId, options = {}) {
     );
   }
 }
-async function callHermesApi(path24, init, options) {
+async function callHermesApi(path25, init, options) {
   const method = init.method ?? "GET";
   const startedAt = Date.now();
-  void options.logger?.debug("hermes_api_request_started", { method, path: path24 });
+  void options.logger?.debug("hermes_api_request_started", { method, path: path25 });
   const availability = await ensureHermesApiServerAvailable({
     fetchImpl: options.fetchImpl,
     logger: options.logger,
@@ -9094,21 +10437,21 @@ async function callHermesApi(path24, init, options) {
   });
   let config = availability.configResult.apiServer;
   const fetcher = options.fetchImpl ?? fetch;
-  const request = () => fetchHermesApi(fetcher, config, path24, init, options);
+  const request = () => fetchHermesApi(fetcher, config, path25, init, options);
   let response;
   try {
     response = await request();
   } catch (error) {
-    logHermesApiError(options.logger, method, path24, startedAt, error);
+    logHermesApiError(options.logger, method, path25, startedAt, error);
     throw error;
   }
   if (response.status !== 401) {
-    logHermesApiResponse(options.logger, method, path24, startedAt, response);
+    logHermesApiResponse(options.logger, method, path25, startedAt, response);
     return response;
   }
   void options.logger?.warn("hermes_api_request_retrying_after_401", {
     method,
-    path: path24,
+    path: path25,
     duration_ms: Date.now() - startedAt
   });
   const refreshedAvailability = await ensureHermesApiServerAvailable({
@@ -9121,20 +10464,20 @@ async function callHermesApi(path24, init, options) {
   try {
     response = await request();
   } catch (error) {
-    logHermesApiError(options.logger, method, path24, startedAt, error);
+    logHermesApiError(options.logger, method, path25, startedAt, error);
     throw error;
   }
-  logHermesApiResponse(options.logger, method, path24, startedAt, response);
+  logHermesApiResponse(options.logger, method, path25, startedAt, response);
   return response;
 }
-async function fetchHermesApi(fetcher, config, path24, init, options) {
+async function fetchHermesApi(fetcher, config, path25, 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}${path24}`, {
+  return await fetcher(`http://127.0.0.1:${config.port}${path25}`, {
     ...init,
     headers
   }).catch((error) => {
@@ -9142,7 +10485,7 @@ async function fetchHermesApi(fetcher, config, path24, init, options) {
       throw error;
     }
     void options.logger?.warn("hermes_api_server_connect_failed", {
-      path: path24,
+      path: path25,
       port: config.port ?? null,
       error: error instanceof Error ? error.message : String(error)
     });
@@ -9153,10 +10496,10 @@ async function fetchHermesApi(fetcher, config, path24, init, options) {
     );
   });
 }
-function logHermesApiResponse(logger, method, path24, startedAt, response) {
+function logHermesApiResponse(logger, method, path25, startedAt, response) {
   const fields = {
     method,
-    path: path24,
+    path: path25,
     status: response.status,
     duration_ms: Date.now() - startedAt
   };
@@ -9176,10 +10519,10 @@ async function logHermesApiFailureResponse(logger, fields, response) {
     ...upstreamError ? { upstream_error: upstreamError } : {}
   });
 }
-function logHermesApiError(logger, method, path24, startedAt, error) {
+function logHermesApiError(logger, method, path25, startedAt, error) {
   void logger?.warn("hermes_api_request_failed", {
     method,
-    path: path24,
+    path: path25,
     duration_ms: Date.now() - startedAt,
     ...error instanceof LinkHttpError ? { status: error.status, code: error.code } : {},
     error: error instanceof Error ? error.message : String(error)
@@ -9228,23 +10571,23 @@ function isRecord(value) {
 }
 function readUpstreamMessage(payload, raw) {
   const error = typeof payload?.error === "object" && payload.error !== null ? payload.error : null;
-  const message = readString9(error ?? {}, "message") ?? readString9(payload ?? {}, "message");
+  const message = readString10(error ?? {}, "message") ?? readString10(payload ?? {}, "message");
   if (message) {
     return message;
   }
   const body = raw.trim().replace(/\s+/gu, " ").slice(0, 500);
   return body || "empty response body";
 }
-function readString9(payload, key) {
+function readString10(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 
 // src/conversations/history-builder.ts
-import { readFile as readFile9, stat as stat8 } from "fs/promises";
-import { createRequire as createRequire3 } from "module";
-import path14 from "path";
-var nodeRequire3 = createRequire3(import.meta.url);
+import { readFile as readFile10, stat as stat9 } from "fs/promises";
+import { createRequire as createRequire4 } from "module";
+import path15 from "path";
+var nodeRequire4 = createRequire4(import.meta.url);
 var HISTORY_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
 var HERMES_HISTORY_COLUMNS = [
   "role",
@@ -9305,13 +10648,13 @@ async function readHermesTranscriptHistory(sessionId, profileName) {
   }
   const normalizedProfileName = isValidProfileName2(profileName) ? profileName : "default";
   const profileDir = resolveHermesProfileDir(normalizedProfileName);
-  const dbPath = path14.join(profileDir, "state.db");
+  const dbPath = path15.join(profileDir, "state.db");
   const sessionsDirConfig = await readHermesSessionsDir(normalizedProfileName).then((value) => ({
     sessionsDir: value.sessionsDir,
     configured: value.configured,
     configError: false
   })).catch(() => ({
-    sessionsDir: path14.join(profileDir, "sessions"),
+    sessionsDir: path15.join(profileDir, "sessions"),
     configured: false,
     configError: true
   }));
@@ -9351,8 +10694,8 @@ async function readHermesTranscriptHistory(sessionId, profileName) {
   };
 }
 async function readHermesStateDbHistory(dbPath, sessionId) {
-  const exists = await stat8(dbPath).then((value) => value.isFile()).catch((error) => {
-    if (isNodeError10(error, "ENOENT")) {
+  const exists = await stat9(dbPath).then((value) => value.isFile()).catch((error) => {
+    if (isNodeError11(error, "ENOENT")) {
       return false;
     }
     throw error;
@@ -9369,9 +10712,9 @@ async function readHermesJsonlHistory(sessionsDir, sessionId) {
   if (!isValidSessionFileStem(sessionId)) {
     return empty;
   }
-  const transcriptPath = path14.join(sessionsDir, `${sessionId}.jsonl`);
-  const raw = await readFile9(transcriptPath, "utf8").catch((error) => {
-    if (isNodeError10(error, "ENOENT")) {
+  const transcriptPath = path15.join(sessionsDir, `${sessionId}.jsonl`);
+  const raw = await readFile10(transcriptPath, "utf8").catch((error) => {
+    if (isNodeError11(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -9406,14 +10749,14 @@ async function readHermesJsonlHistory(sessionsDir, sessionId) {
 function readHistoryRows(dbPath, sessionId) {
   let db = null;
   try {
-    const { DatabaseSync } = nodeRequire3(
+    const { DatabaseSync } = nodeRequire4(
       "node:sqlite"
     );
     db = new DatabaseSync(dbPath, {
       readOnly: true,
       timeout: 1e3
     });
-    const columns = readTableColumns(db, "messages");
+    const columns = readTableColumns2(db, "messages");
     if (!columns.has("role") || !columns.has("content")) {
       return [];
     }
@@ -9518,7 +10861,7 @@ function normalizeHistoryMessage(role, content) {
   if (role !== "user" && role !== "assistant") {
     return null;
   }
-  const text = normalizeContent(content).trim();
+  const text = normalizeContent2(content).trim();
   if (!text) {
     return null;
   }
@@ -9529,7 +10872,7 @@ function normalizeHistoryRecord(record) {
   if (!role) {
     return null;
   }
-  const content = normalizeContent(record.content);
+  const content = normalizeContent2(record.content);
   const message = { role, content };
   assignString(message, "tool_call_id", record.tool_call_id);
   assignString(message, "tool_name", record.tool_name);
@@ -9549,7 +10892,7 @@ function normalizeHistoryRecord(record) {
   }
   return message;
 }
-function normalizeContent(value) {
+function normalizeContent2(value) {
   if (typeof value === "string") {
     return value;
   }
@@ -9591,12 +10934,12 @@ function hasReplayMetadata(message) {
     message.tool_call_id || message.tool_name || message.tool_calls || message.reasoning || message.reasoning_content || message.reasoning_details || message.codex_reasoning_items
   );
 }
-function readTableColumns(db, table) {
+function readTableColumns2(db, table) {
   return new Set(
     db.prepare(`PRAGMA table_info(${table})`).all().map((row) => row.name).filter((name) => typeof name === "string")
   );
 }
-function isNodeError10(error, code) {
+function isNodeError11(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 function isValidProfileName2(value) {
@@ -9614,8 +10957,8 @@ function normalizeProfileForCompare(value) {
 
 // src/hermes/stt.ts
 import { execFile as execFile3 } from "child_process";
-import { access as access2, readFile as readFile10, stat as stat9 } from "fs/promises";
-import path15 from "path";
+import { access as access2, readFile as readFile11, stat as stat10 } from "fs/promises";
+import path16 from "path";
 import { promisify as promisify3 } from "util";
 var execFileAsync3 = promisify3(execFile3);
 var STT_RESULT_PREFIX = "__HERMES_LINK_STT__";
@@ -9710,7 +11053,7 @@ async function buildHermesSttEnv(profileName) {
   };
   const devSource = await findDevHermesAgentSource();
   if (devSource) {
-    env.PYTHONPATH = [devSource, env.PYTHONPATH].filter(Boolean).join(path15.delimiter);
+    env.PYTHONPATH = [devSource, env.PYTHONPATH].filter(Boolean).join(path16.delimiter);
   }
   return env;
 }
@@ -9757,14 +11100,14 @@ async function resolveHermesPythonCommand() {
   };
 }
 async function resolveExecutablePath(command) {
-  if (path15.isAbsolute(command)) {
+  if (path16.isAbsolute(command)) {
     return await isExecutableFile(command) ? command : null;
   }
   const pathEnv = process.env.PATH ?? "";
   const extensions = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
-  for (const dir of pathEnv.split(path15.delimiter)) {
+  for (const dir of pathEnv.split(path16.delimiter)) {
     for (const extension of extensions) {
-      const candidate = path15.join(dir, `${command}${extension}`);
+      const candidate = path16.join(dir, `${command}${extension}`);
       if (await isExecutableFile(candidate)) {
         return candidate;
       }
@@ -9774,7 +11117,7 @@ async function resolveExecutablePath(command) {
 }
 async function isExecutableFile(filePath) {
   try {
-    const info = await stat9(filePath);
+    const info = await stat10(filePath);
     if (!info.isFile()) {
       return false;
     }
@@ -9785,7 +11128,7 @@ async function isExecutableFile(filePath) {
   }
 }
 async function readShebang(filePath) {
-  const raw = await readFile10(filePath, "utf8").catch(() => "");
+  const raw = await readFile11(filePath, "utf8").catch(() => "");
   const firstLine = raw.split(/\r?\n/u)[0]?.trim() ?? "";
   return firstLine.startsWith("#!") ? firstLine.slice(2).trim() : null;
 }
@@ -9804,8 +11147,8 @@ function shebangToPythonCommand(shebang) {
 }
 async function findDevHermesAgentSource() {
   const candidates = [
-    path15.resolve(process.cwd(), "reference/hermes-agent"),
-    path15.resolve(process.cwd(), "../../reference/hermes-agent")
+    path16.resolve(process.cwd(), "reference/hermes-agent"),
+    path16.resolve(process.cwd(), "../../reference/hermes-agent")
   ];
   for (const candidate of candidates) {
     if (await isDirectory(candidate)) {
@@ -9815,7 +11158,7 @@ async function findDevHermesAgentSource() {
   return null;
 }
 async function isDirectory(candidate) {
-  return stat9(candidate).then((info) => info.isDirectory()).catch(() => false);
+  return stat10(candidate).then((info) => info.isDirectory()).catch(() => false);
 }
 function compactProcessOutput(value) {
   const compact = value.trim().replace(/\s+/gu, " ").slice(0, 500);
@@ -9867,8 +11210,8 @@ function parseSseBlock(block) {
   if (decoded === null) {
     return null;
   }
-  const payload = toRecord8(decoded);
-  const payloadType = (readString10(payload, "type") ?? readString10(payload, "event") ?? readString10(payload, "object") ?? eventName) || "message";
+  const payload = toRecord9(decoded);
+  const payloadType = (readString11(payload, "type") ?? readString11(payload, "event") ?? readString11(payload, "object") ?? eventName) || "message";
   return { eventName, payloadType, payload, rawPayload: decoded ?? raw };
 }
 function decodeJson(value) {
@@ -9884,11 +11227,11 @@ function decodeJson(value) {
     return { type: "message.delta", delta: value };
   }
 }
-function readString10(body, key) {
+function readString11(body, key) {
   const value = body[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function toRecord8(value) {
+function toRecord9(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 
@@ -9912,8 +11255,8 @@ function normalizeHermesStreamEvent(event) {
     };
   }
   if (event.eventName === "hermes.tool.progress") {
-    const toolName = readString11(event.payload, "tool") ?? readString11(event.payload, "name") ?? "tool";
-    const preview = readString11(event.payload, "label") ?? readString11(event.payload, "preview") ?? toolName;
+    const toolName = readString12(event.payload, "tool") ?? readString12(event.payload, "name") ?? "tool";
+    const preview = readString12(event.payload, "label") ?? readString12(event.payload, "preview") ?? toolName;
     return {
       ...event,
       payloadType: "tool.started",
@@ -9981,12 +11324,12 @@ function normalizeHermesResponseEvent(event) {
   }
 }
 function normalizeResponseOutputItemAdded(event) {
-  const item = toRecord9(event.payload.item);
-  if (readString11(item, "type") !== "function_call") {
+  const item = toRecord10(event.payload.item);
+  if (readString12(item, "type") !== "function_call") {
     return null;
   }
-  const toolName = readString11(item, "name") ?? "tool";
-  const argumentsValue = parseJsonValue(item.arguments) ?? item.arguments;
+  const toolName = readString12(item, "name") ?? "tool";
+  const argumentsValue = parseJsonValue2(item.arguments) ?? item.arguments;
   return {
     ...event,
     payloadType: "tool.started",
@@ -9995,60 +11338,60 @@ function normalizeResponseOutputItemAdded(event) {
       tool: toolName,
       tool_name: toolName,
       name: toolName,
-      tool_call_id: readString11(item, "call_id") ?? readString11(item, "id"),
+      tool_call_id: readString12(item, "call_id") ?? readString12(item, "id"),
       arguments: argumentsValue,
       preview: toolName,
-      response_item_id: readString11(item, "id") ?? void 0
+      response_item_id: readString12(item, "id") ?? void 0
     }
   };
 }
 function normalizeResponseOutputItemDone(event) {
-  const item = toRecord9(event.payload.item);
-  if (readString11(item, "type") !== "function_call_output") {
+  const item = toRecord10(event.payload.item);
+  if (readString12(item, "type") !== "function_call_output") {
     return null;
   }
   const output = readResponseItemOutput(item.output);
-  const parsedOutput = parseJsonValue(output);
+  const parsedOutput = parseJsonValue2(output);
   return {
     ...event,
     payloadType: "tool.completed",
     payload: {
       type: "tool.completed",
-      tool_call_id: readString11(item, "call_id") ?? readString11(item, "id"),
-      status: readString11(item, "status") ?? "completed",
+      tool_call_id: readString12(item, "call_id") ?? readString12(item, "id"),
+      status: readString12(item, "status") ?? "completed",
       output,
       content: output,
       result: parsedOutput ?? output,
-      response_item_id: readString11(item, "id") ?? void 0
+      response_item_id: readString12(item, "id") ?? void 0
     }
   };
 }
 function normalizeResponseCompleted(event) {
-  const response = toRecord9(event.payload.response);
+  const response = toRecord10(event.payload.response);
   return {
     ...event,
     payloadType: "run.completed",
     payload: {
       type: "run.completed",
-      response_id: readString11(response, "id") ?? readString11(event.payload, "id"),
-      usage: toRecord9(response.usage),
+      response_id: readString12(response, "id") ?? readString12(event.payload, "id"),
+      usage: toRecord10(response.usage),
       response
     }
   };
 }
 function normalizeResponseFailed(event) {
-  const response = toRecord9(event.payload.response);
-  const error = toRecord9(response.error);
+  const response = toRecord10(event.payload.response);
+  const error = toRecord10(response.error);
   return {
     ...event,
     payloadType: "run.failed",
     payload: {
       type: "run.failed",
-      response_id: readString11(response, "id") ?? readString11(event.payload, "id"),
+      response_id: readString12(response, "id") ?? readString12(event.payload, "id"),
       error: {
-        message: readString11(error, "message") ?? readString11(event.payload, "message") ?? "Hermes run failed"
+        message: readString12(error, "message") ?? readString12(event.payload, "message") ?? "Hermes run failed"
       },
-      usage: toRecord9(response.usage),
+      usage: toRecord10(response.usage),
       response
     }
   };
@@ -10072,8 +11415,8 @@ function readErrorMessage2(payload) {
   if (typeof payload.error === "string" && payload.error.trim()) {
     return payload.error.trim();
   }
-  const error = toRecord9(payload.error);
-  return readString11(error, "message") ?? readString11(payload, "message");
+  const error = toRecord10(payload.error);
+  return readString12(error, "message") ?? readString12(payload, "message");
 }
 function readDelta(payload) {
   return readText2(payload, "delta") ?? readText2(payload, "text") ?? readText2(payload, "content");
@@ -10108,20 +11451,21 @@ function isTopLevelErrorEvent(event) {
 }
 function readChatCompletionDelta(payload) {
   const choice = readFirstChoice(payload);
-  const delta = toRecord9(choice.delta);
+  const delta = toRecord10(choice.delta);
   return readText2(delta, "content");
 }
 function readChatCompletionFinishReason(payload) {
   const choice = readFirstChoice(payload);
-  return readString11(choice, "finish_reason") ?? readString11(choice, "finishReason");
+  return readString12(choice, "finish_reason") ?? readString12(choice, "finishReason");
 }
 function readChatCompletionUsage(payload) {
-  const usage = toRecord9(payload.usage);
+  const usage = toRecord10(payload.usage);
   const input = readInteger2(usage, "prompt_tokens") ?? readInteger2(usage, "input_tokens");
   const output = readInteger2(usage, "completion_tokens") ?? readInteger2(usage, "output_tokens");
   const total = readInteger2(usage, "total_tokens");
-  const contextWindow = readInteger2(usage, "context_window") ?? readInteger2(usage, "context_max");
+  const contextWindow = readInteger2(usage, "context_window") ?? readInteger2(usage, "context_max") ?? readInteger2(usage, "context_length");
   const explicitContextTokens = readInteger2(usage, "context_tokens") ?? readInteger2(usage, "context_used") ?? readInteger2(usage, "current_context_tokens") ?? readInteger2(usage, "last_prompt_tokens");
+  const explicitUsagePercent = readInteger2(usage, "usage_percent") ?? readInteger2(usage, "context_percent");
   if (input === void 0 && output === void 0 && total === void 0) {
     return void 0;
   }
@@ -10132,7 +11476,7 @@ function readChatCompletionUsage(payload) {
     ...explicitContextTokens !== void 0 ? { context_tokens: explicitContextTokens } : {},
     ...contextWindow !== void 0 ? { context_window: contextWindow } : {},
     ...explicitContextTokens !== void 0 && contextWindow ? {
-      usage_percent: Math.min(
+      usage_percent: explicitUsagePercent !== void 0 ? Math.min(100, explicitUsagePercent) : Math.min(
         100,
         Math.round(explicitContextTokens / contextWindow * 100)
       )
@@ -10144,7 +11488,7 @@ function readFirstChoice(payload) {
   if (!Array.isArray(choices)) {
     return {};
   }
-  return toRecord9(choices[0]);
+  return toRecord10(choices[0]);
 }
 function readInteger2(payload, key) {
   const value = payload[key];
@@ -10157,7 +11501,7 @@ function readInteger2(payload, key) {
   }
   return void 0;
 }
-function readString11(payload, key) {
+function readString12(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
@@ -10172,10 +11516,10 @@ function readResponseItemOutput(value) {
   if (!Array.isArray(value)) {
     return stringifyJsonValue(value);
   }
-  const text = value.map(toRecord9).map((part) => readText2(part, "text") ?? readText2(part, "content") ?? "").join("");
+  const text = value.map(toRecord10).map((part) => readText2(part, "text") ?? readText2(part, "content") ?? "").join("");
   return text || stringifyJsonValue(value);
 }
-function parseJsonValue(value) {
+function parseJsonValue2(value) {
   if (typeof value !== "string" || !value.trim()) {
     return null;
   }
@@ -10198,7 +11542,7 @@ function stringifyJsonValue(value) {
     return String(value);
   }
 }
-function toRecord9(value) {
+function toRecord10(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 
@@ -10279,10 +11623,20 @@ var ConversationRunLifecycle = class {
         });
         return void 0;
       });
+      const instructions = buildRunInstructions(run, deliveryStagingDir);
+      const estimatedUsage = estimateContextUsage({
+        conversationHistory: conversationHistory.messages,
+        currentInput: resolvedInput,
+        instructions,
+        contextWindow: run.context_window
+      });
+      if (estimatedUsage) {
+        await this.updateRun(conversationId, runId, { usage: estimatedUsage });
+      }
       const response = await streamHermesResponses(
         {
           input: resolvedInput,
-          instructions: buildRunInstructions(run, deliveryStagingDir),
+          instructions,
           session_id: hermesSessionId,
           model: run.model,
           ...previousResponseId ? { previous_response_id: previousResponseId } : {},
@@ -10615,7 +11969,7 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
       assistant.agent_events ?? [],
       agentEvent
     );
-    appendAgentEventBlock(assistant, agentEvent, event.created_at);
+    appendAgentEventBlock2(assistant, agentEvent, event.created_at);
     assistant.updated_at = event.created_at;
     await this.deps.writeSnapshot(conversationId, snapshot);
   }
@@ -10684,8 +12038,8 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
     }
     const textPart = assistant.parts.find((part) => part.type === "text");
     const currentText = textPart?.text ?? "";
-    const pendingDeliveryText = readString12(
-      toRecord10(assistant.hermes),
+    const pendingDeliveryText = readString13(
+      toRecord11(assistant.hermes),
       "pending_media_delivery_text"
     );
     const normalizedDelta = normalizeStreamingTextDelta(
@@ -10700,7 +12054,7 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
       pendingDeliveryText ?? ""
     );
     const nextHermes = {
-      ...toRecord10(assistant.hermes),
+      ...toRecord11(assistant.hermes),
       ...extracted.pendingText ? { pending_media_delivery_text: extracted.pendingText } : {}
     };
     if (!extracted.pendingText) {
@@ -10716,7 +12070,7 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
     assistant.updated_at = (/* @__PURE__ */ new Date()).toISOString();
     assistant.raw = { format: "hermes-run-event", payload: event.rawPayload };
     if (extracted.visibleText) {
-      appendTextBlock(assistant, extracted.visibleText, assistant.updated_at);
+      appendTextBlock2(assistant, extracted.visibleText, assistant.updated_at);
     }
     await this.deps.writeSnapshot(conversationId, snapshot);
     if (extracted.visibleText) {
@@ -10785,7 +12139,7 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
       run.hermes_response_id = responseId;
     }
     if (usage) {
-      run.usage = usage;
+      run.usage = mergeRunUsage(run.usage, usage);
     }
     if (assistant) {
       assistant.status = "completed";
@@ -10837,7 +12191,7 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
     const visibleMessage = formatFailureMessage(message, run.error_detail);
     const usage = readUsage(source?.payload);
     if (usage) {
-      run.usage = usage;
+      run.usage = mergeRunUsage(run.usage, usage);
     }
     const assistant = snapshot.messages.find(
       (item) => item.id === run.assistant_message_id
@@ -10856,6 +12210,7 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
       }
     }
     await this.deps.writeSnapshot(conversationId, snapshot);
+    const contextUsage = contextUsagePayload(run);
     await this.deps.appendEvent(conversationId, {
       type: "run.failed",
       message_id: assistant?.id,
@@ -10864,6 +12219,7 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
         error: { message },
         ...run.error_detail ? { error_detail: run.error_detail } : {},
         run,
+        ...contextUsage ? { context: contextUsage } : {},
         ...source ? { hermes: source.payload } : {}
       },
       ...source ? { raw: { format: "hermes-run-event", payload: source.rawPayload } } : {}
@@ -10967,7 +12323,7 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
       includeDisabled: true
     });
     return new Set(
-      jobs.map((job) => readString12(job, "id") ?? readString12(job, "job_id")).filter((id) => Boolean(id))
+      jobs.map((job) => readString13(job, "id") ?? readString13(job, "job_id")).filter((id) => Boolean(id))
     );
   }
   async bindNewCronJobsCreatedByRun(input) {
@@ -11003,7 +12359,7 @@ function buildRunInstructions(run, deliveryStagingDir) {
   ].join("\n");
 }
 function appendMediaImportFailureNotice(message) {
-  const hermes = toRecord10(message.hermes);
+  const hermes = toRecord11(message.hermes);
   if (hermes.media_import_failure_notice_appended === true) {
     return;
   }
@@ -11046,18 +12402,18 @@ function formatFilenameList(filenames) {
   return remaining > 0 ? `${preview.join("\u3001")} \u7B49 ${filenames.length} \u4E2A` : preview.join("\u3001");
 }
 async function readdirWithDirs(directory) {
-  return readdir6(directory, { withFileTypes: true }).catch((error) => {
-    if (isNodeError11(error, "ENOENT")) {
+  return readdir7(directory, { withFileTypes: true }).catch((error) => {
+    if (isNodeError12(error, "ENOENT")) {
       return [];
     }
     throw error;
   });
 }
-function readString12(payload, key) {
+function readString13(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function toRecord10(value) {
+function toRecord11(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function formatFailureMessage(message, detail) {
@@ -11073,17 +12429,17 @@ function isFileSearchCompletion(payloadType, payload) {
   if (payloadType !== "tool.completed") {
     return false;
   }
-  const tool = toRecord10(payload.tool);
-  const toolCall = toRecord10(payload.tool_call ?? payload.toolCall);
-  const fn = toRecord10(toolCall.function ?? payload.function);
+  const tool = toRecord11(payload.tool);
+  const toolCall = toRecord11(payload.tool_call ?? payload.toolCall);
+  const fn = toRecord11(toolCall.function ?? payload.function);
   const candidates = [
-    readString12(payload, "tool_name"),
-    readString12(payload, "toolName"),
-    readString12(payload, "name"),
-    readString12(payload, "tool"),
-    readString12(tool, "name"),
-    readString12(toolCall, "name"),
-    readString12(fn, "name")
+    readString13(payload, "tool_name"),
+    readString13(payload, "toolName"),
+    readString13(payload, "name"),
+    readString13(payload, "tool"),
+    readString13(tool, "name"),
+    readString13(toolCall, "name"),
+    readString13(fn, "name")
   ].filter((value) => Boolean(value)).map(normalizeToolName);
   return candidates.some(
     (name) => [
@@ -11126,7 +12482,7 @@ function isVoicePart(part) {
 function normalizeToolName(value) {
   return value.trim().toLowerCase().replace(/[\s-]+/gu, "_");
 }
-function appendTextBlock(message, delta, updatedAt) {
+function appendTextBlock2(message, delta, updatedAt) {
   if (!delta) {
     return;
   }
@@ -11149,7 +12505,7 @@ function appendTextBlock(message, delta, updatedAt) {
   }
   message.blocks = blocks;
 }
-function appendAgentEventBlock(message, event, updatedAt) {
+function appendAgentEventBlock2(message, event, updatedAt) {
   const blocks = [...message.blocks ?? []];
   const matchingIndex = blocks.findIndex((block) => {
     if (block.type !== "agent_events") {
@@ -11195,6 +12551,7 @@ function contextUsagePayload(run) {
       source: "unknown"
     };
   }
+  const contextSource = usage.context_source ?? "explicit";
   return {
     input_tokens: contextTokens,
     output_tokens: usage?.output_tokens ?? 0,
@@ -11202,7 +12559,7 @@ function contextUsagePayload(run) {
     ...contextWindow ? { context_window: contextWindow } : {},
     used_tokens: contextTokens,
     ...contextWindow ? { window_tokens: contextWindow } : {},
-    source: "explicit",
+    source: contextSource,
     ...usage?.usage_percent !== void 0 ? { usage_percent: usage.usage_percent } : contextWindow ? {
       usage_percent: Math.min(
         100,
@@ -11211,6 +12568,41 @@ function contextUsagePayload(run) {
     } : {}
   };
 }
+function mergeRunUsage(previous, next) {
+  const nextContextWindow = next.context_window ?? previous?.context_window;
+  const nextContextTokens = next.context_tokens ?? refineEstimatedContextTokens(
+    previous,
+    next.input_tokens,
+    nextContextWindow
+  );
+  const nextContextSource = next.context_tokens !== void 0 ? next.context_source ?? "explicit" : nextContextTokens !== void 0 ? previous?.context_source : void 0;
+  return {
+    ...next,
+    ...nextContextTokens !== void 0 ? { context_tokens: nextContextTokens } : {},
+    ...nextContextWindow !== void 0 ? { context_window: nextContextWindow } : {},
+    ...nextContextSource ? { context_source: nextContextSource } : {},
+    ...nextContextTokens !== void 0 && nextContextWindow ? {
+      usage_percent: next.usage_percent ?? previous?.usage_percent ?? Math.min(
+        100,
+        Math.round(nextContextTokens / nextContextWindow * 100)
+      )
+    } : {}
+  };
+}
+function refineEstimatedContextTokens(previous, inputTokens, contextWindow) {
+  if (previous?.context_source !== "estimated") {
+    return void 0;
+  }
+  const currentEstimate = previous.context_tokens;
+  if (currentEstimate === void 0) {
+    return void 0;
+  }
+  const upperBound = inputTokens > 0 ? contextWindow ? Math.min(inputTokens, contextWindow) : inputTokens : contextWindow;
+  if (upperBound === void 0) {
+    return currentEstimate;
+  }
+  return Math.min(currentEstimate, upperBound);
+}
 function findPreviousHermesResponseId(snapshot, run) {
   const currentProfile = normalizeRunProfileForCompare(run.profile);
   if (!currentProfile) {
@@ -11238,10 +12630,10 @@ function readResponseId(payload) {
   if (!payload) {
     return null;
   }
-  const response = toRecord10(payload.response);
-  return readString12(payload, "response_id") ?? readString12(response, "id");
+  const response = toRecord11(payload.response);
+  return readString13(payload, "response_id") ?? readString13(response, "id");
 }
-function isNodeError11(error, code) {
+function isNodeError12(error, code) {
   if (typeof error !== "object" || error === null || !("code" in error)) {
     return false;
   }
@@ -11330,6 +12722,7 @@ var ConversationService = class {
   orchestration;
   queries;
   runLifecycle;
+  hermesSessionSyncPromise = null;
   async withConversationLock(conversationId, task) {
     const previous = this.conversationLocks.get(conversationId) ?? Promise.resolve();
     let release;
@@ -11390,7 +12783,7 @@ var ConversationService = class {
   async createConversation(input = {}) {
     await this.store.ensureConversationsDir();
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const id = `conv_${randomUUID6().replaceAll("-", "")}`;
+    const id = `conv_${randomUUID7().replaceAll("-", "")}`;
     const title = input.title?.trim() || DEFAULT_CONVERSATION_TITLE;
     const profile = await resolveConversationProfileTarget(
       this.paths,
@@ -11477,7 +12870,7 @@ var ConversationService = class {
         manifest.profile_name_snapshot ?? manifest.profile ?? input.profileName
       );
       const message = {
-        id: `msg_${randomUUID6().replaceAll("-", "")}`,
+        id: `msg_${randomUUID7().replaceAll("-", "")}`,
         schema_version: 1,
         conversation_id: manifest.id,
         role: "assistant",
@@ -11521,6 +12914,29 @@ var ConversationService = class {
   async syncCronDeliveries() {
     await syncHermesLinkCronDeliveries(this.paths, this, this.logger);
   }
+  async syncHermesSessions() {
+    if (this.hermesSessionSyncPromise) {
+      return this.hermesSessionSyncPromise;
+    }
+    const task = (async () => {
+      const result = await syncHermesSessionsIntoConversations(
+        this.paths,
+        this.logger
+      );
+      if (result.imported_count > 0 || result.reprojected_count > 0) {
+        await this.rebuildStatisticsIndex();
+      }
+      return result;
+    })();
+    this.hermesSessionSyncPromise = task;
+    try {
+      return await task;
+    } finally {
+      if (this.hermesSessionSyncPromise === task) {
+        this.hermesSessionSyncPromise = null;
+      }
+    }
+  }
   async deliverStagedFiles(stagingDir) {
     const target = resolveDeliveryStagingTarget(this.paths, stagingDir);
     return this.withConversationLock(target.conversationId, async () => {
@@ -12046,7 +13462,7 @@ function findApproval(snapshot, approvalId) {
 }
 
 // src/identity/identity.ts
-import { generateKeyPairSync, randomUUID as randomUUID7, sign } from "crypto";
+import { generateKeyPairSync, randomUUID as randomUUID8, sign } from "crypto";
 import { mkdir as mkdir9, chmod } from "fs/promises";
 import { z } from "zod";
 var linkIdentitySchema = z.object({
@@ -12074,7 +13490,7 @@ async function ensureIdentity(paths = resolveRuntimePaths()) {
   const { publicKey, privateKey } = generateKeyPairSync("ed25519");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const identity = {
-    install_id: `install_${randomUUID7().replaceAll("-", "")}`,
+    install_id: `install_${randomUUID8().replaceAll("-", "")}`,
     link_id: null,
     public_key_pem: publicKey.export({ type: "spki", format: "pem" }).toString(),
     private_key_pem: privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
@@ -12111,7 +13527,7 @@ function getIdentityStatus(identity) {
 }
 
 // src/security/devices.ts
-import { randomBytes as randomBytes2, randomUUID as randomUUID8, timingSafeEqual, createHash as createHash4 } from "crypto";
+import { randomBytes as randomBytes2, randomUUID as randomUUID9, timingSafeEqual, createHash as createHash4 } from "crypto";
 var ACCESS_TOKEN_TTL_MS = 15 * 60 * 1e3;
 var REFRESH_TOKEN_TTL_MS = 90 * 24 * 60 * 60 * 1e3;
 var DEVICE_SEEN_WRITE_INTERVAL_MS = 60 * 60 * 1e3;
@@ -12129,7 +13545,7 @@ async function createDeviceSession(input, paths = resolveRuntimePaths()) {
     }
   }
   const device = {
-    id: `dev_${randomUUID8().replaceAll("-", "")}`,
+    id: `dev_${randomUUID9().replaceAll("-", "")}`,
     label: normalizeDeviceLabel(input.label),
     platform: normalizeDevicePlatform(input.platform),
     model: normalizeDeviceModel(input.model),
@@ -12578,12 +13994,12 @@ async function readRawBody(request, maxBytes) {
   }
   return Buffer.concat(chunks);
 }
-function readString13(body, key) {
+function readString14(body, key) {
   const value = body[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function readOptionalProfileName(body) {
-  return readString13(body, "profile") ?? readString13(body, "profile_name") ?? readString13(body, "profileName") ?? void 0;
+  return readString14(body, "profile") ?? readString14(body, "profile_name") ?? readString14(body, "profileName") ?? void 0;
 }
 function readStringArray(body, ...keys) {
   for (const key of keys) {
@@ -12621,7 +14037,7 @@ function readPositiveInteger2(value) {
   }
   return void 0;
 }
-function readBoolean(value) {
+function readBoolean2(value) {
   if (typeof value === "boolean") {
     return value;
   }
@@ -12724,7 +14140,7 @@ function readMessageAttachments(value) {
     }
     const kind = readAttachmentString(record.kind);
     const type = readAttachmentString(record.type);
-    const isVoiceNote = readBoolean(record.is_voice_note) ?? readBoolean(record.isVoiceNote);
+    const isVoiceNote = readBoolean2(record.is_voice_note) ?? readBoolean2(record.isVoiceNote);
     const durationMs = readPositiveInteger2(record.duration_ms) ?? readPositiveInteger2(record.durationMs);
     const waveform = readAttachmentWaveform2(
       record.waveform ?? record.waveform_samples ?? record.waveformSamples
@@ -12790,13 +14206,84 @@ function isLanHost(hostname) {
 }
 
 // src/http/sse.ts
+var DEFAULT_SSE_RETRY_MS = 1e3;
+var DEFAULT_SSE_HEARTBEAT_MS = 15e3;
+function beginSseStream(request, response, options = {}) {
+  const retryMs = normalizeRetryMs(options.retryMs);
+  const heartbeatMs = Math.max(1e3, options.heartbeatMs ?? DEFAULT_SSE_HEARTBEAT_MS);
+  response.statusCode = 200;
+  response.setHeader("content-type", "text/event-stream; charset=utf-8");
+  response.setHeader("cache-control", "no-store");
+  response.setHeader("connection", "keep-alive");
+  response.flushHeaders();
+  writeSseRetry(response, retryMs);
+  writeSseComment(response, options.initialComment ?? "connected");
+  let closed = false;
+  let heartbeat = null;
+  const cleanup = () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    if (heartbeat != null) {
+      clearInterval(heartbeat);
+      heartbeat = null;
+    }
+    request.off("close", cleanup);
+    response.off("close", cleanup);
+    options.onClose?.();
+    if (!response.writableEnded && !response.destroyed) {
+      response.end();
+    }
+  };
+  heartbeat = setInterval(() => {
+    if (response.writableEnded || response.destroyed) {
+      cleanup();
+      return;
+    }
+    writeSseComment(response);
+  }, heartbeatMs);
+  heartbeat.unref();
+  request.once("close", cleanup);
+  response.once("close", cleanup);
+  return cleanup;
+}
 function writeSseEvent(response, event) {
-  response.write(`event: ${event.type}
+  writeJsonSseEvent(response, {
+    event: event.type,
+    data: event,
+    id: event.seq
+  });
+}
+function writeJsonSseEvent(response, event) {
+  if (event.retryMs != null) {
+    response.write(`retry: ${normalizeRetryMs(event.retryMs)}
+`);
+  }
+  if (event.id != null && event.id !== "") {
+    response.write(`id: ${event.id}
+`);
+  }
+  response.write(`event: ${event.event}
 `);
-  response.write(`data: ${JSON.stringify(event)}
+  response.write(`data: ${JSON.stringify(event.data)}
 
 `);
 }
+function writeSseComment(response, comment = "keep-alive") {
+  response.write(`: ${comment}
+
+`);
+}
+function writeSseRetry(response, retryMs) {
+  response.write(`retry: ${normalizeRetryMs(retryMs)}
+
+`);
+}
+function normalizeRetryMs(retryMs) {
+  const parsed = Number.isFinite(retryMs) ? Math.trunc(retryMs) : DEFAULT_SSE_RETRY_MS;
+  return parsed >= 0 ? parsed : DEFAULT_SSE_RETRY_MS;
+}
 
 // src/http/routes/conversations.ts
 function registerConversationRoutes(router, options) {
@@ -12816,7 +14303,7 @@ function registerConversationRoutes(router, options) {
     ctx.body = {
       ok: true,
       conversation: await conversations.createConversation({
-        title: readString13(body, "title") ?? void 0,
+        title: readString14(body, "title") ?? void 0,
         profileName: readOptionalProfileName(body)
       })
     };
@@ -12840,54 +14327,49 @@ function registerConversationRoutes(router, options) {
     const notificationOnly = mode === "notifications";
     ctx.respond = false;
     const response = ctx.res;
-    response.statusCode = 200;
-    response.setHeader("content-type", "text/event-stream; charset=utf-8");
-    response.setHeader("cache-control", "no-store");
-    response.setHeader("connection", "keep-alive");
-    const unsubscribe = conversations.subscribeAll((event) => {
+    let unsubscribe = () => {
+    };
+    beginSseStream(ctx.req, response, {
+      onClose: () => unsubscribe()
+    });
+    unsubscribe = conversations.subscribeAll((event) => {
       if (notificationOnly && !isConversationNotificationEvent(event)) {
         return;
       }
       writeSseEvent(response, event);
     });
-    const cleanup = () => {
-      unsubscribe();
-      response.end();
-    };
-    ctx.req.on("close", cleanup);
   });
   router.get("/api/v1/conversations/:conversationId/events", async (ctx) => {
     await authenticateRequest(ctx, paths);
-    const after = readInteger3(ctx.query.after) ?? 0;
+    const after = resolveConversationEventCursor({
+      queryAfter: ctx.query.after,
+      lastEventIdHeader: ctx.req.headers["last-event-id"]
+    });
     const history = await conversations.listEvents(
       ctx.params.conversationId,
       after
     );
     ctx.respond = false;
     const response = ctx.res;
-    response.statusCode = 200;
-    response.setHeader("content-type", "text/event-stream; charset=utf-8");
-    response.setHeader("cache-control", "no-store");
-    response.setHeader("connection", "keep-alive");
+    let unsubscribe = () => {
+    };
+    beginSseStream(ctx.req, response, {
+      onClose: () => unsubscribe()
+    });
     for (const event of history) {
       writeSseEvent(response, event);
     }
-    const unsubscribe = conversations.subscribe(
+    unsubscribe = conversations.subscribe(
       ctx.params.conversationId,
       (event) => {
         writeSseEvent(response, event);
       }
     );
-    const cleanup = () => {
-      unsubscribe();
-      response.end();
-    };
-    ctx.req.on("close", cleanup);
   });
   router.post("/api/v1/conversations/:conversationId/messages", async (ctx) => {
     await authenticateRequest(ctx, paths);
     const body = await readJsonBody(ctx.req);
-    const content = readString13(body, "content") ?? readString13(body, "text") ?? readString13(body, "input") ?? "";
+    const content = readString14(body, "content") ?? readString14(body, "text") ?? readString14(body, "input") ?? "";
     const attachments = readMessageAttachments(body.attachments ?? body.blobs);
     if (!content && attachments.length === 0) {
       throw new LinkHttpError(
@@ -12903,7 +14385,7 @@ function registerConversationRoutes(router, options) {
         conversationId: ctx.params.conversationId,
         content,
         attachments,
-        clientMessageId: readString13(body, "client_message_id") ?? readString13(body, "clientMessageId") ?? void 0,
+        clientMessageId: readString14(body, "client_message_id") ?? readString14(body, "clientMessageId") ?? void 0,
         idempotencyKey: readHeader(ctx, "idempotency-key") ?? void 0,
         profileName: readOptionalProfileName(body)
       })
@@ -12912,7 +14394,7 @@ function registerConversationRoutes(router, options) {
   router.patch("/api/v1/conversations/:conversationId/model", async (ctx) => {
     await authenticateRequest(ctx, paths);
     const body = await readJsonBody(ctx.req);
-    const modelId = readString13(body, "model_id") ?? readString13(body, "modelId") ?? readString13(body, "model");
+    const modelId = readString14(body, "model_id") ?? readString14(body, "modelId") ?? readString14(body, "model");
     if (!modelId) {
       throw new LinkHttpError(400, "model_id_required", "model_id is required");
     }
@@ -12942,7 +14424,7 @@ function registerConversationRoutes(router, options) {
   router.patch("/api/v1/conversations/:conversationId/title", async (ctx) => {
     await authenticateRequest(ctx, paths);
     const body = await readJsonBody(ctx.req);
-    const title = readString13(body, "title") ?? readString13(body, "name") ?? readString13(body, "display_name");
+    const title = readString14(body, "title") ?? readString14(body, "name") ?? readString14(body, "display_name");
     if (!title) {
       throw new LinkHttpError(400, "title_required", "title is required");
     }
@@ -13006,7 +14488,7 @@ function registerConversationRoutes(router, options) {
     async (ctx) => {
       await authenticateRequest(ctx, paths);
       const body = await readJsonBody(ctx.req);
-      const scope = readString13(body, "scope") ?? "always";
+      const scope = readString14(body, "scope") ?? "always";
       ctx.body = {
         ok: true,
         ...await conversations.resolveApproval({
@@ -13085,6 +14567,19 @@ function registerConversationRoutes(router, options) {
     }
   );
 }
+function resolveConversationEventCursor(input) {
+  const queryAfter = readInteger3(input.queryAfter) ?? 0;
+  const headerAfter = readNonNegativeIntegerHeader(input.lastEventIdHeader) ?? 0;
+  return Math.max(queryAfter, headerAfter);
+}
+function readNonNegativeIntegerHeader(value) {
+  const raw = Array.isArray(value) ? value[0] : value;
+  if (!raw) {
+    return null;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
+}
 function contentDispositionInline(filename) {
   const fallback = asciiFilenameFallback(filename);
   return `inline; filename="${fallback}"; filename*=UTF-8''${encodeRfc5987Value(filename)}`;
@@ -13166,26 +14661,26 @@ function createHttpErrorMiddleware(logger) {
 }
 
 // src/hermes/profiles.ts
-import { mkdir as mkdir10, readdir as readdir7, readFile as readFile11, rename as rename4, rm as rm6, stat as stat10 } from "fs/promises";
-import os4 from "os";
-import path16 from "path";
+import { mkdir as mkdir10, readdir as readdir8, readFile as readFile12, rename as rename4, rm as rm6, stat as stat11 } from "fs/promises";
+import os5 from "os";
+import path17 from "path";
 import YAML2 from "yaml";
 var DEFAULT_PROFILE = "default";
-var PROFILE_NAME_PATTERN3 = /^[a-zA-Z0-9._-]{1,64}$/;
+var PROFILE_NAME_PATTERN4 = /^[a-zA-Z0-9._-]{1,64}$/;
 async function listHermesProfiles(paths = resolveRuntimePaths()) {
   const profiles = /* @__PURE__ */ new Map();
   profiles.set(DEFAULT_PROFILE, await profileInfo(DEFAULT_PROFILE, paths));
-  const profilesDir = path16.join(os4.homedir(), ".hermes", "profiles");
-  const entries = await readdir7(profilesDir, { withFileTypes: true }).catch(
+  const profilesDir = path17.join(os5.homedir(), ".hermes", "profiles");
+  const entries = await readdir8(profilesDir, { withFileTypes: true }).catch(
     (error) => {
-      if (isNodeError12(error, "ENOENT")) {
+      if (isNodeError13(error, "ENOENT")) {
         return [];
       }
       throw error;
     }
   );
   for (const entry of entries) {
-    if (entry.isDirectory() && PROFILE_NAME_PATTERN3.test(entry.name)) {
+    if (entry.isDirectory() && PROFILE_NAME_PATTERN4.test(entry.name)) {
       profiles.set(entry.name, await profileInfo(entry.name, paths));
     }
   }
@@ -13202,8 +14697,8 @@ async function listHermesProfiles(paths = resolveRuntimePaths()) {
 async function getHermesProfileStatus(name, paths = resolveRuntimePaths()) {
   assertProfileName(name);
   const profile = await profileInfo(name, paths);
-  const exists = await stat10(profile.path).then((value) => value.isDirectory()).catch((error) => {
-    if (isNodeError12(error, "ENOENT")) {
+  const exists = await stat11(profile.path).then((value) => value.isDirectory()).catch((error) => {
+    if (isNodeError13(error, "ENOENT")) {
       return false;
     }
     throw error;
@@ -13243,8 +14738,8 @@ async function updateHermesProfileMetadata(name, metadata, paths = resolveRuntim
 async function deleteHermesProfile(name, paths = resolveRuntimePaths()) {
   assertMutableProfile(name);
   const profile = await profileInfo(name, paths);
-  const exists = await stat10(profile.path).then((value) => value.isDirectory()).catch((error) => {
-    if (isNodeError12(error, "ENOENT")) {
+  const exists = await stat11(profile.path).then((value) => value.isDirectory()).catch((error) => {
+    if (isNodeError13(error, "ENOENT")) {
       return false;
     }
     throw error;
@@ -13270,7 +14765,7 @@ async function readHermesProfileCapabilities(name) {
   return {
     defaultModel: listedModels?.defaultModel ?? null,
     modelCount: listedModels?.models.length ?? 0,
-    skillCount: await countSkills(path16.join(profileDir, "skills")).catch(
+    skillCount: await countSkills(path17.join(profileDir, "skills")).catch(
       () => 0
     ),
     toolCount: await countConfiguredTools(name).catch(() => 0)
@@ -13308,17 +14803,17 @@ function assertMutableProfile(name) {
   }
 }
 function assertProfileName(name) {
-  if (!PROFILE_NAME_PATTERN3.test(name)) {
+  if (!PROFILE_NAME_PATTERN4.test(name)) {
     throw new LinkHttpError(400, "invalid_profile_name", "invalid profile name");
   }
 }
-function isNodeError12(error, code) {
+function isNodeError13(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 async function countSkills(root) {
-  const entries = await readdir7(root, { withFileTypes: true }).catch(
+  const entries = await readdir8(root, { withFileTypes: true }).catch(
     (error) => {
-      if (isNodeError12(error, "ENOENT")) {
+      if (isNodeError13(error, "ENOENT")) {
         return [];
       }
       throw error;
@@ -13326,7 +14821,7 @@ async function countSkills(root) {
   );
   let count = 0;
   for (const entry of entries) {
-    const entryPath = path16.join(root, entry.name);
+    const entryPath = path17.join(root, entry.name);
     if (entry.name === ".git" || entry.name === ".hub") {
       continue;
     }
@@ -13341,11 +14836,11 @@ async function countSkills(root) {
   return count;
 }
 async function countConfiguredTools(profileName) {
-  const raw = await readFile11(
+  const raw = await readFile12(
     resolveHermesConfigPath(profileName),
     "utf8"
   ).catch((error) => {
-    if (isNodeError12(error, "ENOENT")) {
+    if (isNodeError13(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -13353,14 +14848,14 @@ async function countConfiguredTools(profileName) {
   if (!raw.trim()) {
     return 0;
   }
-  const config = toRecord11(YAML2.parse(raw));
+  const config = toRecord12(YAML2.parse(raw));
   const toolsets = /* @__PURE__ */ new Set();
   collectToolsetValues(config.toolsets, toolsets);
-  const platformToolsets = toRecord11(config.platform_toolsets);
+  const platformToolsets = toRecord12(config.platform_toolsets);
   for (const value of Object.values(platformToolsets)) {
     collectToolsetValues(value, toolsets);
   }
-  const mcpServers = Object.keys(toRecord11(config.mcp_servers)).length;
+  const mcpServers = Object.keys(toRecord12(config.mcp_servers)).length;
   return toolsets.size + mcpServers;
 }
 function collectToolsetValues(value, target) {
@@ -13374,7 +14869,7 @@ function collectToolsetValues(value, target) {
     target.add(value.trim());
   }
 }
-function toRecord11(value) {
+function toRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 
@@ -13571,7 +15066,7 @@ function toHermesCronJobInput(input) {
   };
 }
 async function bindAndDecorateCronJobForHermesLink(input) {
-  const jobId = readString13(input.job, "id") ?? readString13(input.job, "job_id");
+  const jobId = readString14(input.job, "id") ?? readString14(input.job, "job_id");
   if (!jobId) {
     return input.job;
   }
@@ -13588,9 +15083,9 @@ async function bindAndDecorateCronJobForHermesLink(input) {
 }
 function readCronJobCreateInput(body) {
   const input = {};
-  const name = readString13(body, "name") ?? readString13(body, "title");
-  const prompt = readString13(body, "prompt") ?? readString13(body, "description") ?? readString13(body, "task");
-  const schedule = readString13(body, "schedule");
+  const name = readString14(body, "name") ?? readString14(body, "title");
+  const prompt = readString14(body, "prompt") ?? readString14(body, "description") ?? readString14(body, "task");
+  const schedule = readString14(body, "schedule");
   if (!name) {
     throw new LinkHttpError(400, "cron_job_name_required", "name is required");
   }
@@ -13611,7 +15106,7 @@ function readCronJobCreateInput(body) {
   input.name = name;
   input.prompt = prompt;
   input.schedule = schedule;
-  input.deliver = readString13(body, "deliver") ?? HERMES_LINK_CRON_DELIVER;
+  input.deliver = readString14(body, "deliver") ?? HERMES_LINK_CRON_DELIVER;
   const skills = readOptionalCronSkills(body);
   if (skills) {
     input.skills = skills;
@@ -13669,7 +15164,7 @@ function readCronJobUpdateInput(body) {
   if (repeat !== void 0) {
     input.repeat = repeat;
   }
-  const enabled = readBoolean(body.enabled);
+  const enabled = readBoolean2(body.enabled);
   if (enabled !== void 0) {
     input.enabled = enabled;
   }
@@ -13839,7 +15334,7 @@ function registerModelConfigRoutes(router, options) {
   router.delete("/api/v1/model-configs", async (ctx) => {
     await authenticateRequest(ctx, paths);
     const body = await readJsonBody(ctx.req);
-    const modelId = readString13(body, "model_id") ?? readString13(body, "modelId");
+    const modelId = readString14(body, "model_id") ?? readString14(body, "modelId");
     if (!modelId) {
       throw new LinkHttpError(400, "model_id_required", "model_id is required");
     }
@@ -13894,7 +15389,7 @@ function registerModelConfigRoutes(router, options) {
     await authenticateRequest(ctx, paths);
     await getHermesProfileStatus(ctx.params.name, paths);
     const body = await readJsonBody(ctx.req);
-    const modelId = readString13(body, "model_id") ?? readString13(body, "modelId");
+    const modelId = readString14(body, "model_id") ?? readString14(body, "modelId");
     if (!modelId) {
       throw new LinkHttpError(400, "model_id_required", "model_id is required");
     }
@@ -13911,9 +15406,9 @@ function registerModelConfigRoutes(router, options) {
   });
 }
 function readModelConfigInput(body) {
-  const id = readString13(body, "id") ?? readString13(body, "model_id") ?? readString13(body, "modelId");
-  const provider = readString13(body, "provider") ?? readString13(body, "provider_key") ?? readString13(body, "providerKey");
-  const baseUrl = readString13(body, "base_url") ?? readString13(body, "baseUrl");
+  const id = readString14(body, "id") ?? readString14(body, "model_id") ?? readString14(body, "modelId");
+  const provider = readString14(body, "provider") ?? readString14(body, "provider_key") ?? readString14(body, "providerKey");
+  const baseUrl = readString14(body, "base_url") ?? readString14(body, "baseUrl");
   if (!id || !provider || !baseUrl) {
     throw new LinkHttpError(
       400,
@@ -13923,28 +15418,28 @@ function readModelConfigInput(body) {
   }
   return {
     id,
-    originalModelId: readString13(body, "original_model_id") ?? readString13(body, "originalModelId") ?? readString13(body, "original_id") ?? void 0,
+    originalModelId: readString14(body, "original_model_id") ?? readString14(body, "originalModelId") ?? readString14(body, "original_id") ?? void 0,
     provider,
-    providerName: readString13(body, "provider_name") ?? readString13(body, "providerName") ?? void 0,
+    providerName: readString14(body, "provider_name") ?? readString14(body, "providerName") ?? void 0,
     baseUrl,
-    apiKey: readString13(body, "api_key") ?? readString13(body, "apiKey") ?? void 0,
-    apiMode: readString13(body, "api_mode") ?? readString13(body, "apiMode") ?? void 0,
+    apiKey: readString14(body, "api_key") ?? readString14(body, "apiKey") ?? void 0,
+    apiMode: readString14(body, "api_mode") ?? readString14(body, "apiMode") ?? void 0,
     contextLength: readPositiveInteger2(
       body.context_length ?? body.contextLength
     ),
-    keyEnv: readString13(body, "key_env") ?? readString13(body, "keyEnv") ?? void 0,
-    setDefault: readBoolean(body.set_default ?? body.setDefault),
-    reasoningEffort: readString13(body, "reasoning_effort") ?? readString13(body, "reasoningEffort") ?? void 0
+    keyEnv: readString14(body, "key_env") ?? readString14(body, "keyEnv") ?? void 0,
+    setDefault: readBoolean2(body.set_default ?? body.setDefault),
+    reasoningEffort: readString14(body, "reasoning_effort") ?? readString14(body, "reasoningEffort") ?? void 0
   };
 }
 function readModelDefaultsInput(body) {
   return {
-    taskModelId: readString13(body, "task_model_id") ?? readString13(body, "taskModelId") ?? readString13(body, "default_model_id") ?? readString13(body, "defaultModelId") ?? void 0,
-    compressionModelId: readString13(body, "compression_model_id") ?? readString13(body, "compressionModelId") ?? void 0
+    taskModelId: readString14(body, "task_model_id") ?? readString14(body, "taskModelId") ?? readString14(body, "default_model_id") ?? readString14(body, "defaultModelId") ?? void 0,
+    compressionModelId: readString14(body, "compression_model_id") ?? readString14(body, "compressionModelId") ?? void 0
   };
 }
 function shouldReloadGatewayAfterModelConfigChange(body) {
-  const explicit = readBoolean(body.reload_gateway ?? body.reloadGateway) ?? (readBoolean(body.skip_gateway_reload ?? body.skipGatewayReload) === true ? false : void 0);
+  const explicit = readBoolean2(body.reload_gateway ?? body.reloadGateway) ?? (readBoolean2(body.skip_gateway_reload ?? body.skipGatewayReload) === true ? false : void 0);
   return explicit ?? true;
 }
 function markModelConfigAppliedWithoutGatewayReload(result) {
@@ -14025,19 +15520,19 @@ import {
   copyFile as copyFile2,
   cp,
   mkdir as mkdir11,
-  readFile as readFile12,
+  readFile as readFile13,
   rm as rm7,
-  stat as stat11,
+  stat as stat12,
   writeFile as writeFile4,
   rename as rename5
 } from "fs/promises";
-import path17 from "path";
+import path18 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_PATTERN4 = /^[a-z0-9][a-z0-9_-]{0,63}$/u;
+var PROFILE_NAME_PATTERN5 = /^[a-z0-9][a-z0-9_-]{0,63}$/u;
 var ALL_COPY_SCOPES = [
   "models",
   "skills",
@@ -14289,7 +15784,7 @@ function normalizeOptionalProfileName(value) {
   if (!trimmed) {
     return null;
   }
-  if (!PROFILE_NAME_PATTERN4.test(trimmed)) {
+  if (!PROFILE_NAME_PATTERN5.test(trimmed)) {
     throw new LinkHttpError(
       400,
       "invalid_profile_name",
@@ -14421,7 +15916,7 @@ function copyModelConfig(source, target) {
       copied[key] = cloneJson(source[key]);
     }
   }
-  const sourceAuxiliary = toRecord12(source.auxiliary);
+  const sourceAuxiliary = toRecord13(source.auxiliary);
   if (Object.prototype.hasOwnProperty.call(sourceAuxiliary, "compression")) {
     const targetAuxiliary = ensureRecord2(target, "auxiliary");
     targetAuxiliary.compression = cloneJson(sourceAuxiliary.compression);
@@ -14430,12 +15925,12 @@ function copyModelConfig(source, target) {
   return copied;
 }
 function copyToolPermissionsConfig(source, target) {
-  const sourcePlatformToolsets = toRecord12(source.platform_toolsets);
+  const sourcePlatformToolsets = toRecord13(source.platform_toolsets);
   if (Object.prototype.hasOwnProperty.call(sourcePlatformToolsets, "api_server")) {
     const targetPlatformToolsets = ensureRecord2(target, "platform_toolsets");
     targetPlatformToolsets.api_server = cloneJson(sourcePlatformToolsets.api_server);
   }
-  const sourceStt = toRecord12(source.stt);
+  const sourceStt = toRecord13(source.stt);
   if (Object.prototype.hasOwnProperty.call(sourceStt, "enabled")) {
     const targetStt = ensureRecord2(target, "stt");
     targetStt.enabled = cloneJson(sourceStt.enabled);
@@ -14482,9 +15977,9 @@ function collectEnvKeys(value, keys = /* @__PURE__ */ new Set()) {
   return keys;
 }
 async function writeEnvValues(profileName, values) {
-  const envPath = path17.join(resolveHermesProfileDir(profileName), ".env");
-  const existingRaw = await readFile12(envPath, "utf8").catch((error) => {
-    if (isNodeError13(error, "ENOENT")) {
+  const envPath = path18.join(resolveHermesProfileDir(profileName), ".env");
+  const existingRaw = await readFile13(envPath, "utf8").catch((error) => {
+    if (isNodeError14(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -14509,7 +16004,7 @@ async function writeEnvValues(profileName, values) {
     nextLines.push(`${key}=${formatEnvValue2(value)}`);
   }
   const nextRaw = nextLines.join("\n").replace(/\n*$/u, "\n");
-  await mkdir11(path17.dirname(envPath), { recursive: true, mode: 448 });
+  await mkdir11(path18.dirname(envPath), { recursive: true, mode: 448 });
   if (existingRaw) {
     await copyFile2(envPath, `${envPath}.bak.${Date.now()}`);
   }
@@ -14518,8 +16013,8 @@ async function writeEnvValues(profileName, values) {
   await rename5(tempPath, envPath);
 }
 async function copySkills(sourceProfile, targetProfile) {
-  const sourceSkills = path17.join(resolveHermesProfileDir(sourceProfile), "skills");
-  const targetSkills = path17.join(resolveHermesProfileDir(targetProfile), "skills");
+  const sourceSkills = path18.join(resolveHermesProfileDir(sourceProfile), "skills");
+  const targetSkills = path18.join(resolveHermesProfileDir(targetProfile), "skills");
   if (!await pathExists(sourceSkills)) {
     return;
   }
@@ -14538,21 +16033,21 @@ function copyProperty(source, target, key) {
   }
 }
 async function readYamlConfig(configPath) {
-  const existingRaw = await readFile12(configPath, "utf8").catch(
+  const existingRaw = await readFile13(configPath, "utf8").catch(
     (error) => {
-      if (isNodeError13(error, "ENOENT")) {
+      if (isNodeError14(error, "ENOENT")) {
         return null;
       }
       throw error;
     }
   );
   return {
-    config: toRecord12(existingRaw ? YAML3.parse(existingRaw) : {}),
+    config: toRecord13(existingRaw ? YAML3.parse(existingRaw) : {}),
     existingRaw
   };
 }
 async function writeYamlConfig(configPath, input) {
-  await mkdir11(path17.dirname(configPath), { recursive: true, mode: 448 });
+  await mkdir11(path18.dirname(configPath), { recursive: true, mode: 448 });
   if (input.existingRaw) {
     await copyFile2(configPath, `${configPath}.bak.${Date.now()}`);
   }
@@ -14600,7 +16095,7 @@ async function writeProfileCreationState(paths, state) {
   await writeJsonFile(profileCreationStatePath(paths), state);
 }
 async function readProfileCreationLogLines(paths) {
-  const raw = await readFile12(profileCreationLogPath(paths), "utf8").catch(() => "");
+  const raw = await readFile13(profileCreationLogPath(paths), "utf8").catch(() => "");
   if (!raw.trim()) {
     return [];
   }
@@ -14609,10 +16104,10 @@ async function readProfileCreationLogLines(paths) {
   );
 }
 function profileCreationStatePath(paths) {
-  return path17.join(paths.runDir, "profile-create-state.json");
+  return path18.join(paths.runDir, "profile-create-state.json");
 }
 function profileCreationLogPath(paths) {
-  return path17.join(paths.logsDir, PROFILE_CREATE_LOG_FILE);
+  return path18.join(paths.logsDir, PROFILE_CREATE_LOG_FILE);
 }
 async function clearProfileCreationLogFiles(paths) {
   const primary = profileCreationLogPath(paths);
@@ -14625,8 +16120,8 @@ async function clearProfileCreationLogFiles(paths) {
   ]);
 }
 async function pathExists(targetPath) {
-  return await stat11(targetPath).then(() => true).catch((error) => {
-    if (isNodeError13(error, "ENOENT")) {
+  return await stat12(targetPath).then(() => true).catch((error) => {
+    if (isNodeError14(error, "ENOENT")) {
       return false;
     }
     throw error;
@@ -14658,7 +16153,7 @@ function ensureRecord2(target, key) {
   target[key] = next;
   return next;
 }
-function toRecord12(value) {
+function toRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 function cloneJson(value) {
@@ -14673,7 +16168,7 @@ function formatEnvValue2(value) {
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
-function isNodeError13(error, code) {
+function isNodeError14(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 
@@ -14758,16 +16253,16 @@ function readProfilePermissionsInput(body) {
   const approvals = readOptionalObject(body, "approvals");
   if (approvals) {
     input.approvals = {
-      mode: readString13(approvals, "mode") ?? readString13(approvals, "approval_mode") ?? readString13(approvals, "approvalMode") ?? void 0,
+      mode: readString14(approvals, "mode") ?? readString14(approvals, "approval_mode") ?? readString14(approvals, "approvalMode") ?? void 0,
       timeout: readPositiveInteger2(approvals.timeout),
-      cronMode: readString13(approvals, "cron_mode") ?? readString13(approvals, "cronMode") ?? void 0
+      cronMode: readString14(approvals, "cron_mode") ?? readString14(approvals, "cronMode") ?? void 0
     };
   }
   const terminal = readOptionalObject(body, "terminal");
   if (terminal) {
     input.terminal = {
-      backend: readString13(terminal, "backend") ?? void 0,
-      cwd: readString13(terminal, "cwd") ?? void 0,
+      backend: readString14(terminal, "backend") ?? void 0,
+      cwd: readString14(terminal, "cwd") ?? void 0,
       containerCpu: readPositiveInteger2(
         terminal.container_cpu ?? terminal.containerCpu
       ),
@@ -14777,7 +16272,7 @@ function readProfilePermissionsInput(body) {
       containerDisk: readPositiveInteger2(
         terminal.container_disk ?? terminal.containerDisk
       ),
-      containerPersistent: readBoolean(
+      containerPersistent: readBoolean2(
         terminal.container_persistent ?? terminal.containerPersistent
       )
     };
@@ -14789,7 +16284,7 @@ function readProfilePermissionsInput(body) {
         toolsets.enabled_toolsets ?? toolsets.enabledToolsets ?? toolsets.enabled,
         "toolsets.enabled"
       ) ?? void 0,
-      mcpEnabled: readBoolean(toolsets.mcp_enabled ?? toolsets.mcpEnabled)
+      mcpEnabled: readBoolean2(toolsets.mcp_enabled ?? toolsets.mcpEnabled)
     };
   }
   if (Object.keys(input).length === 0) {
@@ -14884,13 +16379,13 @@ import {
   access as access3,
   copyFile as copyFile3,
   mkdir as mkdir12,
-  readdir as readdir8,
-  readFile as readFile13,
+  readdir as readdir9,
+  readFile as readFile14,
   rename as rename6,
-  stat as stat12,
+  stat as stat13,
   writeFile as writeFile5
 } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 import YAML4 from "yaml";
 var ENTRY_DELIMITER = "\n\xA7\n";
 var DEFAULT_MEMORY_LIMIT = 2200;
@@ -15107,7 +16602,7 @@ async function saveProviderSettings(profileName, provider, patch) {
   if (provider === "hindsight") {
     await patchJsonProviderConfig(
       profileName,
-      path18.join("hindsight", "config.json"),
+      path19.join("hindsight", "config.json"),
       {
         mode: patch.mode,
         api_url: patch.apiUrl,
@@ -15160,7 +16655,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 = toRecord13(parsed);
+  const config = toRecord14(parsed);
   if (Object.keys(config).length === 0 && parsed !== null) {
     throw new HermesMemoryError(
       "memory_provider_config_invalid",
@@ -15201,7 +16696,7 @@ function isSensitiveConfigKey(key) {
 }
 async function writeCustomProviderConfig(profileName, provider, config) {
   const configPath = customProviderConfigPath(profileName, provider);
-  await mkdir12(path18.dirname(configPath), { recursive: true, mode: 448 });
+  await mkdir12(path19.dirname(configPath), { recursive: true, mode: 448 });
   await writeFile5(configPath, `${JSON.stringify(config, null, 2)}
 `, {
     encoding: "utf8",
@@ -15252,21 +16747,21 @@ function normalizeCustomProviderId(provider) {
 }
 async function patchHermesMemoryProvider(profileName, provider) {
   const configPath = resolveHermesConfigPath(profileName);
-  const existingRaw = await readFile13(configPath, "utf8").catch(
+  const existingRaw = await readFile14(configPath, "utf8").catch(
     (error) => {
-      if (isNodeError14(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return null;
       }
       throw error;
     }
   );
   const document = existingRaw ? YAML4.parseDocument(existingRaw) : new YAML4.Document({});
-  const config = toRecord13(document.toJSON());
-  const memory = toRecord13(config.memory);
+  const config = toRecord14(document.toJSON());
+  const memory = toRecord14(config.memory);
   memory.provider = provider === "built-in" ? "" : provider;
   config.memory = memory;
   const backupPath = existingRaw ? `${configPath}.bak.${Date.now()}` : null;
-  await mkdir12(path18.dirname(configPath), { recursive: true, mode: 448 });
+  await mkdir12(path19.dirname(configPath), { recursive: true, mode: 448 });
   if (backupPath) {
     await copyFile3(configPath, backupPath);
   }
@@ -15279,13 +16774,13 @@ async function patchHermesMemoryProvider(profileName, provider) {
   await rename6(tempPath, configPath);
 }
 function resolveMemoryDir(profileName) {
-  return path18.join(resolveHermesProfileDir(profileName), "memories");
+  return path19.join(resolveHermesProfileDir(profileName), "memories");
 }
 async function readMemoryStore(profileName, target, limits) {
   const filePath = memoryFilePath(profileName, target);
   const entries = await readMemoryEntries(filePath);
-  const fileStat = await stat12(filePath).catch((error) => {
-    if (isNodeError14(error, "ENOENT")) {
+  const fileStat = await stat13(filePath).catch((error) => {
+    if (isNodeError15(error, "ENOENT")) {
       return null;
     }
     throw error;
@@ -15313,8 +16808,8 @@ async function readMemoryStore(profileName, target, limits) {
   };
 }
 async function readMemoryEntries(filePath) {
-  const raw = await readFile13(filePath, "utf8").catch((error) => {
-    if (isNodeError14(error, "ENOENT")) {
+  const raw = await readFile14(filePath, "utf8").catch((error) => {
+    if (isNodeError15(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -15334,9 +16829,9 @@ async function mutateMemoryEntries(profileName, target, mutate) {
 async function writeMemoryEntries(profileName, target, entries) {
   assertWithinLimit(target, entries, await readMemoryLimits(profileName));
   const filePath = memoryFilePath(profileName, target);
-  const dir = path18.dirname(filePath);
+  const dir = path19.dirname(filePath);
   await mkdir12(dir, { recursive: true, mode: 448 });
-  const tempPath = path18.join(
+  const tempPath = path19.join(
     dir,
     `.mem_${process.pid}_${Date.now()}_${target}.tmp`
   );
@@ -15347,7 +16842,7 @@ async function writeMemoryEntries(profileName, target, entries) {
   await rename6(tempPath, filePath);
 }
 function memoryFilePath(profileName, target) {
-  return path18.join(
+  return path19.join(
     resolveMemoryDir(profileName),
     target === "user" ? "USER.md" : "MEMORY.md"
   );
@@ -15407,7 +16902,7 @@ async function readCustomProviderSetupSummary(profileName) {
     configurable: true,
     configured: true,
     configurationIssue: null,
-    providerConfigPath: path18.join(
+    providerConfigPath: path19.join(
       resolveHermesProfileDir(profileName),
       "<provider>.json"
     ),
@@ -15485,7 +16980,7 @@ async function readProviderConfigurationStatus(profileName, provider) {
     const config2 = await readJsonObject(
       memoryProviderConfigPath(profileName, "honcho") ?? ""
     );
-    return isConfiguredEnvValue(env.HONCHO_API_KEY) || isConfiguredEnvValue(readString14(config2.apiKey)) || isConfiguredEnvValue(readString14(config2.api_key)) || isConfiguredEnvValue(readString14(config2.baseUrl)) ? { configured: true, issue: null } : {
+    return isConfiguredEnvValue(env.HONCHO_API_KEY) || isConfiguredEnvValue(readString15(config2.apiKey)) || isConfiguredEnvValue(readString15(config2.api_key)) || isConfiguredEnvValue(readString15(config2.baseUrl)) ? { configured: true, issue: null } : {
       configured: false,
       issue: "Honcho \u9700\u8981\u5148\u914D\u7F6E HONCHO_API_KEY\uFF0C\u6216\u5728 honcho.json \u914D\u7F6E self-hosted baseUrl\u3002"
     };
@@ -15494,7 +16989,7 @@ async function readProviderConfigurationStatus(profileName, provider) {
     const config2 = await readJsonObject(
       memoryProviderConfigPath(profileName, "mem0") ?? ""
     );
-    return isConfiguredEnvValue(env.MEM0_API_KEY) || isConfiguredEnvValue(readString14(config2.api_key)) ? { configured: true, issue: null } : {
+    return isConfiguredEnvValue(env.MEM0_API_KEY) || isConfiguredEnvValue(readString15(config2.api_key)) ? { configured: true, issue: null } : {
       configured: false,
       issue: "Mem0 \u9700\u8981\u5148\u5728\u672C\u673A Hermes .env \u914D\u7F6E MEM0_API_KEY\u3002"
     };
@@ -15536,7 +17031,7 @@ async function readProviderConfigurationStatus(profileName, provider) {
     memoryProviderConfigPath(profileName, provider) ?? ""
   );
   const mode = normalizeHindsightMode(config.mode ?? env.HINDSIGHT_MODE);
-  const apiKey = readString14(config.apiKey) ?? readString14(config.api_key) ?? env.HINDSIGHT_API_KEY;
+  const apiKey = readString15(config.apiKey) ?? readString15(config.api_key) ?? env.HINDSIGHT_API_KEY;
   if (mode === "cloud") {
     return isConfiguredEnvValue(apiKey) ? { configured: true, issue: null } : {
       configured: false,
@@ -15544,15 +17039,15 @@ async function readProviderConfigurationStatus(profileName, provider) {
     };
   }
   if (mode === "local_external") {
-    const apiUrl = readString14(config.api_url) ?? env.HINDSIGHT_API_URL ?? HINDSIGHT_DEFAULT_LOCAL_URL;
+    const apiUrl = readString15(config.api_url) ?? env.HINDSIGHT_API_URL ?? HINDSIGHT_DEFAULT_LOCAL_URL;
     return isConfiguredEnvValue(apiUrl) ? { configured: true, issue: null } : {
       configured: false,
       issue: "Hindsight local_external \u9700\u8981\u914D\u7F6E\u53EF\u8BBF\u95EE\u7684 API URL\u3002"
     };
   }
   if (mode === "local_embedded") {
-    const llmProvider = readString14(config.llm_provider) ?? "openai";
-    const llmModel = readString14(config.llm_model);
+    const llmProvider = readString15(config.llm_provider) ?? "openai";
+    const llmModel = readString15(config.llm_model);
     if (!llmModel) {
       return {
         configured: false,
@@ -15560,7 +17055,7 @@ async function readProviderConfigurationStatus(profileName, provider) {
       };
     }
     if (llmProvider === "openai_compatible" && !isConfiguredEnvValue(
-      readString14(config.llm_base_url) ?? env.HINDSIGHT_API_LLM_BASE_URL
+      readString15(config.llm_base_url) ?? env.HINDSIGHT_API_LLM_BASE_URL
     )) {
       return {
         configured: false,
@@ -15568,7 +17063,7 @@ async function readProviderConfigurationStatus(profileName, provider) {
       };
     }
     if (!["ollama", "lmstudio", "openai_compatible"].includes(llmProvider) && !isConfiguredEnvValue(
-      readString14(config.llmApiKey) ?? readString14(config.llm_api_key) ?? env.HINDSIGHT_LLM_API_KEY
+      readString15(config.llmApiKey) ?? readString15(config.llm_api_key) ?? env.HINDSIGHT_LLM_API_KEY
     )) {
       return {
         configured: false,
@@ -15708,8 +17203,8 @@ async function readProviderSettings(profileName, provider) {
     const config = await readJsonObject(
       memoryProviderConfigPath(profileName, provider) ?? ""
     );
-    const banks = toRecord13(config.banks);
-    const hermesBank = toRecord13(banks.hermes);
+    const banks = toRecord14(config.banks);
+    const hermesBank = toRecord14(banks.hermes);
     const mode = normalizeHindsightMode(config.mode);
     return [
       selectSetting("mode", "\u8FDE\u63A5\u6A21\u5F0F", mode, [
@@ -15761,7 +17256,7 @@ async function readProviderSettings(profileName, provider) {
       stringSetting(
         "dbPath",
         "SQLite \u6570\u636E\u5E93\u8DEF\u5F84",
-        config.db_path ?? path18.join(resolveHermesProfileDir(profileName), "memory_store.db")
+        config.db_path ?? path19.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),
@@ -15784,7 +17279,7 @@ async function readProviderSettings(profileName, provider) {
       stringSetting(
         "workingDirectory",
         "\u5DE5\u4F5C\u76EE\u5F55",
-        path18.join(resolveHermesProfileDir(profileName), "byterover"),
+        path19.join(resolveHermesProfileDir(profileName), "byterover"),
         false
       )
     ];
@@ -15793,16 +17288,16 @@ async function readProviderSettings(profileName, provider) {
 }
 function memoryProviderConfigPath(profileName, provider) {
   if (provider === "honcho") {
-    return path18.join(resolveHermesProfileDir(profileName), "honcho.json");
+    return path19.join(resolveHermesProfileDir(profileName), "honcho.json");
   }
   if (provider === "mem0") {
-    return path18.join(resolveHermesProfileDir(profileName), "mem0.json");
+    return path19.join(resolveHermesProfileDir(profileName), "mem0.json");
   }
   if (provider === "supermemory") {
-    return path18.join(resolveHermesProfileDir(profileName), "supermemory.json");
+    return path19.join(resolveHermesProfileDir(profileName), "supermemory.json");
   }
   if (provider === "hindsight") {
-    return path18.join(
+    return path19.join(
       resolveHermesProfileDir(profileName),
       "hindsight",
       "config.json"
@@ -15811,21 +17306,21 @@ function memoryProviderConfigPath(profileName, provider) {
   return null;
 }
 function customProviderConfigPath(profileName, provider) {
-  return path18.join(
+  return path19.join(
     resolveHermesProfileDir(profileName),
     `${normalizeCustomProviderId(provider)}.json`
   );
 }
 function customProviderRegistryPath(profileName) {
-  return path18.join(
+  return path19.join(
     resolveHermesProfileDir(profileName),
     CUSTOM_PROVIDER_REGISTRY_FILE
   );
 }
 async function readCustomProviderRegistry(profileName) {
-  const raw = await readFile13(customProviderRegistryPath(profileName), "utf8").catch(
+  const raw = await readFile14(customProviderRegistryPath(profileName), "utf8").catch(
     (error) => {
-      if (isNodeError14(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -15836,18 +17331,18 @@ async function readCustomProviderRegistry(profileName) {
   }
   try {
     const parsed = JSON.parse(raw);
-    const providers = Array.isArray(parsed) ? parsed : Array.isArray(toRecord13(parsed).providers) ? toRecord13(parsed).providers : [];
+    const providers = Array.isArray(parsed) ? parsed : Array.isArray(toRecord14(parsed).providers) ? toRecord14(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 = toRecord13(item);
-      const id = normalizeCustomProviderId(readString14(record.id) ?? "");
+      const record = toRecord14(item);
+      const id = normalizeCustomProviderId(readString15(record.id) ?? "");
       return {
         id,
-        label: readString14(record.label) ?? id,
-        description: readString14(record.description) ?? "\u81EA\u5B9A\u4E49 memory provider\u3002"
+        label: readString15(record.label) ?? id,
+        description: readString15(record.description) ?? "\u81EA\u5B9A\u4E49 memory provider\u3002"
       };
     }).filter((item) => item.id);
   } catch {
@@ -15862,7 +17357,7 @@ async function saveCustomProviderRegistryEntry(profileName, provider) {
     { id: providerId, label: providerId, description: "\u81EA\u5B9A\u4E49 memory provider\u3002" }
   ].sort((left, right) => left.id.localeCompare(right.id));
   const registryPath2 = customProviderRegistryPath(profileName);
-  await mkdir12(path18.dirname(registryPath2), { recursive: true, mode: 448 });
+  await mkdir12(path19.dirname(registryPath2), { recursive: true, mode: 448 });
   await writeFile5(
     registryPath2,
     `${JSON.stringify({ providers }, null, 2)}
@@ -15871,10 +17366,10 @@ async function saveCustomProviderRegistryEntry(profileName, provider) {
   );
 }
 async function discoverUserMemoryProviderDescriptors(profileName) {
-  const pluginsDir = path18.join(resolveHermesProfileDir(profileName), "plugins");
-  const entries = await readdir8(pluginsDir, { withFileTypes: true }).catch(
+  const pluginsDir = path19.join(resolveHermesProfileDir(profileName), "plugins");
+  const entries = await readdir9(pluginsDir, { withFileTypes: true }).catch(
     (error) => {
-      if (isNodeError14(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return [];
       }
       throw error;
@@ -15891,21 +17386,21 @@ async function discoverUserMemoryProviderDescriptors(profileName) {
     } catch {
       continue;
     }
-    const providerDir = path18.join(pluginsDir, entry.name);
+    const providerDir = path19.join(pluginsDir, entry.name);
     if (!await isMemoryProviderPluginDir(providerDir)) {
       continue;
     }
     const meta = await readPluginMetadata(providerDir);
     descriptors.push({
       id: providerId,
-      label: readString14(meta.name) ?? providerId,
-      description: readString14(meta.description) ?? "\u81EA\u5B9A\u4E49 memory provider\u3002"
+      label: readString15(meta.name) ?? providerId,
+      description: readString15(meta.description) ?? "\u81EA\u5B9A\u4E49 memory provider\u3002"
     });
   }
   return descriptors;
 }
 async function isUserMemoryProviderInstalled(profileName, provider) {
-  const providerDir = path18.join(
+  const providerDir = path19.join(
     resolveHermesProfileDir(profileName),
     "plugins",
     normalizeCustomProviderId(provider)
@@ -15913,9 +17408,9 @@ async function isUserMemoryProviderInstalled(profileName, provider) {
   return isMemoryProviderPluginDir(providerDir);
 }
 async function isMemoryProviderPluginDir(providerDir) {
-  const source = await readFile13(path18.join(providerDir, "__init__.py"), "utf8").catch(
+  const source = await readFile14(path19.join(providerDir, "__init__.py"), "utf8").catch(
     (error) => {
-      if (isNodeError14(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -15925,22 +17420,22 @@ async function isMemoryProviderPluginDir(providerDir) {
   return sample.includes("register_memory_provider") || sample.includes("MemoryProvider");
 }
 async function readPluginMetadata(providerDir) {
-  const raw = await readFile13(path18.join(providerDir, "plugin.yaml"), "utf8").catch(
+  const raw = await readFile14(path19.join(providerDir, "plugin.yaml"), "utf8").catch(
     (error) => {
-      if (isNodeError14(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return "";
       }
       throw error;
     }
   );
-  return raw ? toRecord13(YAML4.parse(raw)) : {};
+  return raw ? toRecord14(YAML4.parse(raw)) : {};
 }
 async function resolveByteRoverCli() {
   const candidates = [
-    ...(process.env.PATH ?? "").split(path18.delimiter).filter(Boolean).map((dir) => path18.join(dir, "brv")),
-    path18.join(process.env.HOME ?? "", ".brv-cli", "bin", "brv"),
+    ...(process.env.PATH ?? "").split(path19.delimiter).filter(Boolean).map((dir) => path19.join(dir, "brv")),
+    path19.join(process.env.HOME ?? "", ".brv-cli", "bin", "brv"),
     "/usr/local/bin/brv",
-    path18.join(process.env.HOME ?? "", ".npm-global", "bin", "brv")
+    path19.join(process.env.HOME ?? "", ".npm-global", "bin", "brv")
   ].filter(Boolean);
   for (const candidate of candidates) {
     const found = await access3(candidate).then(() => true).catch(() => false);
@@ -15951,32 +17446,32 @@ async function resolveByteRoverCli() {
   return null;
 }
 async function readHolographicProviderConfig(profileName) {
-  const raw = await readFile13(resolveHermesConfigPath(profileName), "utf8").catch(
+  const raw = await readFile14(resolveHermesConfigPath(profileName), "utf8").catch(
     (error) => {
-      if (isNodeError14(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return "";
       }
       throw error;
     }
   );
-  const config = raw ? toRecord13(YAML4.parse(raw)) : {};
-  const plugins = toRecord13(config.plugins);
-  return toRecord13(plugins["hermes-memory-store"]);
+  const config = raw ? toRecord14(YAML4.parse(raw)) : {};
+  const plugins = toRecord14(config.plugins);
+  return toRecord14(plugins["hermes-memory-store"]);
 }
 async function patchHolographicProviderConfig(profileName, patch) {
   const configPath = resolveHermesConfigPath(profileName);
-  const existingRaw = await readFile13(configPath, "utf8").catch(
+  const existingRaw = await readFile14(configPath, "utf8").catch(
     (error) => {
-      if (isNodeError14(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return null;
       }
       throw error;
     }
   );
   const document = existingRaw ? YAML4.parseDocument(existingRaw) : new YAML4.Document({});
-  const config = toRecord13(document.toJSON());
-  const plugins = toRecord13(config.plugins);
-  const memoryStore = toRecord13(plugins["hermes-memory-store"]);
+  const config = toRecord14(document.toJSON());
+  const plugins = toRecord14(config.plugins);
+  const memoryStore = toRecord14(plugins["hermes-memory-store"]);
   for (const [key, value] of Object.entries(patch)) {
     if (value !== void 0) {
       memoryStore[key] = value;
@@ -15984,7 +17479,7 @@ async function patchHolographicProviderConfig(profileName, patch) {
   }
   plugins["hermes-memory-store"] = memoryStore;
   config.plugins = plugins;
-  await mkdir12(path18.dirname(configPath), { recursive: true, mode: 448 });
+  await mkdir12(path19.dirname(configPath), { recursive: true, mode: 448 });
   if (existingRaw) {
     await copyFile3(configPath, `${configPath}.bak.${Date.now()}`);
   }
@@ -16003,9 +17498,9 @@ async function patchHermesMemoryEnv(profileName, patch) {
   if (entries.length === 0) {
     return;
   }
-  const envPath = path18.join(resolveHermesProfileDir(profileName), ".env");
-  const existingRaw = await readFile13(envPath, "utf8").catch((error) => {
-    if (isNodeError14(error, "ENOENT")) {
+  const envPath = path19.join(resolveHermesProfileDir(profileName), ".env");
+  const existingRaw = await readFile14(envPath, "utf8").catch((error) => {
+    if (isNodeError15(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -16035,7 +17530,7 @@ async function patchHermesMemoryEnv(profileName, patch) {
     }
   }
   const nextRaw = nextLines.join("\n").replace(/\n*$/u, "\n");
-  await mkdir12(path18.dirname(envPath), { recursive: true, mode: 448 });
+  await mkdir12(path19.dirname(envPath), { recursive: true, mode: 448 });
   if (existingRaw) {
     await copyFile3(envPath, `${envPath}.bak.${Date.now()}`);
   }
@@ -16054,29 +17549,29 @@ function isMemoryEnvKeyWritable(key) {
   ].includes(key);
 }
 function normalizeHindsightMode(value) {
-  const mode = readString14(value) ?? "cloud";
+  const mode = readString15(value) ?? "cloud";
   return mode === "local" ? "local_embedded" : mode;
 }
 async function readActiveMemoryProvider(profileName) {
-  const raw = await readFile13(
+  const raw = await readFile14(
     resolveHermesConfigPath(profileName),
     "utf8"
   ).catch((error) => {
-    if (isNodeError14(error, "ENOENT")) {
+    if (isNodeError15(error, "ENOENT")) {
       return "";
     }
     throw error;
   });
-  const config = raw ? toRecord13(YAML4.parse(raw)) : {};
-  const memory = toRecord13(config.memory);
-  const provider = readString14(memory.provider);
+  const config = raw ? toRecord14(YAML4.parse(raw)) : {};
+  const memory = toRecord14(config.memory);
+  const provider = readString15(memory.provider);
   if (!provider || provider === "built-in" || provider === "builtin" || provider === "built_in") {
     return null;
   }
   return provider;
 }
 async function patchJsonProviderConfig(profileName, relativePath, patch) {
-  const configPath = path18.join(
+  const configPath = path19.join(
     resolveHermesProfileDir(profileName),
     relativePath
   );
@@ -16087,7 +17582,7 @@ async function patchJsonProviderConfig(profileName, relativePath, patch) {
       next[key] = value;
     }
   }
-  await mkdir12(path18.dirname(configPath), { recursive: true, mode: 448 });
+  await mkdir12(path19.dirname(configPath), { recursive: true, mode: 448 });
   await writeFile5(configPath, `${JSON.stringify(next, null, 2)}
 `, {
     encoding: "utf8",
@@ -16095,18 +17590,18 @@ async function patchJsonProviderConfig(profileName, relativePath, patch) {
   });
 }
 async function readJsonObject(filePath) {
-  const raw = await readFile13(filePath, "utf8").catch((error) => {
-    if (isNodeError14(error, "ENOENT")) {
+  const raw = await readFile14(filePath, "utf8").catch((error) => {
+    if (isNodeError15(error, "ENOENT")) {
       return "{}";
     }
     throw error;
   });
   try {
-    return toRecord13(JSON.parse(raw || "{}"));
+    return toRecord14(JSON.parse(raw || "{}"));
   } catch {
     throw new HermesMemoryError(
       "memory_provider_config_invalid",
-      `${path18.basename(filePath)} \u4E0D\u662F\u6709\u6548\u7684 JSON \u914D\u7F6E\u6587\u4EF6\u3002`
+      `${path19.basename(filePath)} \u4E0D\u662F\u6709\u6548\u7684 JSON \u914D\u7F6E\u6587\u4EF6\u3002`
     );
   }
 }
@@ -16114,7 +17609,7 @@ function booleanSetting(key, label, value) {
   return {
     key,
     label,
-    value: readBoolean2(value) ?? false,
+    value: readBoolean3(value) ?? false,
     editable: true,
     kind: "boolean"
   };
@@ -16127,7 +17622,7 @@ function stringSetting(key, label, value, editable = true) {
   return {
     key,
     label,
-    value: readString14(value) ?? "",
+    value: readString15(value) ?? "",
     editable,
     kind: "string"
   };
@@ -16142,21 +17637,21 @@ function textSetting(key, label, value, editable = true) {
   };
 }
 function selectSetting(key, label, value, options, editable = true) {
-  const stringValue = readString14(value) ?? options[0] ?? null;
+  const stringValue = readString15(value) ?? options[0] ?? null;
   return { key, label, value: stringValue, editable, kind: "select", options };
 }
 async function readMemoryLimits(profileName) {
-  const raw = await readFile13(
+  const raw = await readFile14(
     resolveHermesConfigPath(profileName),
     "utf8"
   ).catch((error) => {
-    if (isNodeError14(error, "ENOENT")) {
+    if (isNodeError15(error, "ENOENT")) {
       return "";
     }
     throw error;
   });
-  const config = raw ? toRecord13(YAML4.parse(raw)) : {};
-  const memory = toRecord13(config.memory);
+  const config = raw ? toRecord14(YAML4.parse(raw)) : {};
+  const memory = toRecord14(config.memory);
   return {
     memory: readPositiveInteger3(memory.memory_char_limit) ?? DEFAULT_MEMORY_LIMIT,
     user: readPositiveInteger3(memory.user_char_limit) ?? DEFAULT_USER_LIMIT
@@ -16212,17 +17707,17 @@ function hashString(value) {
   }
   return hash.toString(16);
 }
-function toRecord13(value) {
+function toRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
-function readString14(value) {
+function readString15(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function readPositiveInteger3(value) {
   const numberValue = typeof value === "number" ? value : typeof value === "string" ? Number(value.trim()) : NaN;
   return Number.isFinite(numberValue) && numberValue > 0 ? Math.floor(numberValue) : void 0;
 }
-function readBoolean2(value) {
+function readBoolean3(value) {
   if (typeof value === "boolean") {
     return value;
   }
@@ -16243,7 +17738,7 @@ function formatEnvValue3(value) {
 function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
-function isNodeError14(error, code) {
+function isNodeError15(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
 
@@ -16357,7 +17852,7 @@ function registerProfileMemoryRoutes(router, options) {
   );
 }
 function readMemoryTarget(body) {
-  const raw = readString13(body, "target");
+  const raw = readString14(body, "target");
   if (raw === "memory" || raw === "user") {
     return raw;
   }
@@ -16368,7 +17863,7 @@ function readMemoryTarget(body) {
   );
 }
 function readMemoryResetTarget(body) {
-  const raw = readString13(body, "target") ?? "all";
+  const raw = readString14(body, "target") ?? "all";
   if (raw === "all" || raw === "memory" || raw === "user") {
     return raw;
   }
@@ -16379,7 +17874,7 @@ function readMemoryResetTarget(body) {
   );
 }
 function readRequiredMemoryContent(body) {
-  const content = readString13(body, "content") ?? readString13(body, "text");
+  const content = readString14(body, "content") ?? readString14(body, "text");
   if (!content) {
     throw new LinkHttpError(
       400,
@@ -16390,7 +17885,7 @@ function readRequiredMemoryContent(body) {
   return content;
 }
 function readRequiredMemoryMatch(body) {
-  const oldText = readString13(body, "old_text") ?? readString13(body, "oldText") ?? readString13(body, "match");
+  const oldText = readString14(body, "old_text") ?? readString14(body, "oldText") ?? readString14(body, "match");
   if (!oldText) {
     throw new LinkHttpError(
       400,
@@ -16401,7 +17896,7 @@ function readRequiredMemoryMatch(body) {
   return oldText;
 }
 function readRequiredMemoryProvider(body) {
-  const provider = readString13(body, "provider") ?? readString13(body, "provider_id") ?? readString13(body, "providerId");
+  const provider = readString14(body, "provider") ?? readString14(body, "provider_id") ?? readString14(body, "providerId");
   if (!provider) {
     throw new LinkHttpError(
       400,
@@ -16413,7 +17908,7 @@ function readRequiredMemoryProvider(body) {
 }
 function readMemorySettingsPatch(body) {
   const input = {};
-  const mode = readString13(body, "mode");
+  const mode = readString14(body, "mode");
   if (mode) {
     input.mode = mode;
   }
@@ -16425,7 +17920,7 @@ function readMemorySettingsPatch(body) {
   if (bankId !== void 0) {
     input.bankId = bankId;
   }
-  const llmProvider = readString13(body, "llm_provider") ?? readString13(body, "llmProvider");
+  const llmProvider = readString14(body, "llm_provider") ?? readString14(body, "llmProvider");
   if (llmProvider) {
     input.llmProvider = llmProvider;
   }
@@ -16441,23 +17936,23 @@ function readMemorySettingsPatch(body) {
   if (containerTag !== void 0) {
     input.containerTag = containerTag;
   }
-  const autoRecall = readBoolean(body.auto_recall ?? body.autoRecall);
+  const autoRecall = readBoolean2(body.auto_recall ?? body.autoRecall);
   if (autoRecall !== void 0) {
     input.autoRecall = autoRecall;
   }
-  const autoCapture = readBoolean(body.auto_capture ?? body.autoCapture);
+  const autoCapture = readBoolean2(body.auto_capture ?? body.autoCapture);
   if (autoCapture !== void 0) {
     input.autoCapture = autoCapture;
   }
-  const autoRetain = readBoolean(body.auto_retain ?? body.autoRetain);
+  const autoRetain = readBoolean2(body.auto_retain ?? body.autoRetain);
   if (autoRetain !== void 0) {
     input.autoRetain = autoRetain;
   }
-  const memoryMode = readString13(body, "memory_mode") ?? readString13(body, "memoryMode");
+  const memoryMode = readString14(body, "memory_mode") ?? readString14(body, "memoryMode");
   if (memoryMode) {
     input.memoryMode = memoryMode;
   }
-  const recallBudget = readString13(body, "recall_budget") ?? readString13(body, "recallBudget");
+  const recallBudget = readString14(body, "recall_budget") ?? readString14(body, "recallBudget");
   if (recallBudget) {
     input.recallBudget = recallBudget;
   }
@@ -16473,11 +17968,11 @@ function readMemorySettingsPatch(body) {
   if (profileFrequency !== void 0) {
     input.profileFrequency = profileFrequency;
   }
-  const captureMode = readString13(body, "capture_mode") ?? readString13(body, "captureMode");
+  const captureMode = readString14(body, "capture_mode") ?? readString14(body, "captureMode");
   if (captureMode) {
     input.captureMode = captureMode;
   }
-  const searchMode = readString13(body, "search_mode") ?? readString13(body, "searchMode");
+  const searchMode = readString14(body, "search_mode") ?? readString14(body, "searchMode");
   if (searchMode) {
     input.searchMode = searchMode;
   }
@@ -16511,19 +18006,19 @@ function readMemorySettingsPatch(body) {
   if (aiPeer !== void 0) {
     input.aiPeer = aiPeer;
   }
-  const recallMode = readString13(body, "recall_mode") ?? readString13(body, "recallMode");
+  const recallMode = readString14(body, "recall_mode") ?? readString14(body, "recallMode");
   if (recallMode) {
     input.recallMode = recallMode;
   }
-  const writeFrequency = readString13(body, "write_frequency") ?? readString13(body, "writeFrequency");
+  const writeFrequency = readString14(body, "write_frequency") ?? readString14(body, "writeFrequency");
   if (writeFrequency) {
     input.writeFrequency = writeFrequency;
   }
-  const saveMessages = readBoolean(body.save_messages ?? body.saveMessages);
+  const saveMessages = readBoolean2(body.save_messages ?? body.saveMessages);
   if (saveMessages !== void 0) {
     input.saveMessages = saveMessages;
   }
-  const sessionStrategy = readString13(body, "session_strategy") ?? readString13(body, "sessionStrategy");
+  const sessionStrategy = readString14(body, "session_strategy") ?? readString14(body, "sessionStrategy");
   if (sessionStrategy) {
     input.sessionStrategy = sessionStrategy;
   }
@@ -16559,7 +18054,7 @@ function readMemorySettingsPatch(body) {
   if (agentId !== void 0) {
     input.agentId = agentId;
   }
-  const rerank = readBoolean(body.rerank);
+  const rerank = readBoolean2(body.rerank);
   if (rerank !== void 0) {
     input.rerank = rerank;
   }
@@ -16583,7 +18078,7 @@ function readMemorySettingsPatch(body) {
   if (dbPath !== void 0) {
     input.dbPath = dbPath;
   }
-  const autoExtract = readBoolean(body.auto_extract ?? body.autoExtract);
+  const autoExtract = readBoolean2(body.auto_extract ?? body.autoExtract);
   if (autoExtract !== void 0) {
     input.autoExtract = autoExtract;
   }
@@ -16654,12 +18149,12 @@ function toMemoryHttpError(error) {
 import {
   copyFile as copyFile4,
   mkdir as mkdir13,
-  readFile as readFile14,
-  readdir as readdir9,
+  readFile as readFile15,
+  readdir as readdir10,
   rename as rename7,
   writeFile as writeFile6
 } from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 import YAML5 from "yaml";
 var HermesSkillNotFoundError = class extends Error {
   constructor(skillName) {
@@ -16673,7 +18168,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 = path19.join(profileDir, "skills");
+  const skillsRoot = path20.join(profileDir, "skills");
   const [skillFiles, disabled, provenance] = await Promise.all([
     findSkillFiles(skillsRoot),
     readDisabledSkillNames(resolveHermesConfigPath(profile.name)),
@@ -16750,9 +18245,9 @@ async function findSkillFiles(root) {
   return results.sort((left, right) => left.localeCompare(right));
 }
 async function collectSkillFiles(directory, results) {
-  const entries = await readdir9(directory, { withFileTypes: true }).catch(
+  const entries = await readdir10(directory, { withFileTypes: true }).catch(
     (error) => {
-      if (isNodeError15(error, "ENOENT")) {
+      if (isNodeError16(error, "ENOENT")) {
         return [];
       }
       throw error;
@@ -16764,7 +18259,7 @@ async function collectSkillFiles(directory, results) {
     if (EXCLUDED_SKILL_DIRS.has(entry.name)) {
       continue;
     }
-    const entryPath = path19.join(directory, entry.name);
+    const entryPath = path20.join(directory, entry.name);
     if (entry.isDirectory()) {
       await collectSkillFiles(entryPath, results);
       continue;
@@ -16775,9 +18270,9 @@ async function collectSkillFiles(directory, results) {
   }
 }
 async function readSkillMetadata(input) {
-  const raw = await readFile14(input.skillFile, "utf8").catch(
+  const raw = await readFile15(input.skillFile, "utf8").catch(
     (error) => {
-      if (isNodeError15(error, "ENOENT") || isNodeError15(error, "EACCES")) {
+      if (isNodeError16(error, "ENOENT") || isNodeError16(error, "EACCES")) {
         return null;
       }
       throw error;
@@ -16786,16 +18281,16 @@ async function readSkillMetadata(input) {
   if (raw === null) {
     return null;
   }
-  const skillDir = path19.dirname(input.skillFile);
+  const skillDir = path20.dirname(input.skillFile);
   const { frontmatter, body } = parseSkillDocument(raw.slice(0, 4e3));
   const name = normalizeSkillName(
-    readString15(frontmatter.name) ?? path19.basename(skillDir)
+    readString16(frontmatter.name) ?? path20.basename(skillDir)
   );
   if (!name) {
     return null;
   }
   const description = normalizeDescription(
-    readString15(frontmatter.description) ?? firstBodyDescription(body)
+    readString16(frontmatter.description) ?? firstBodyDescription(body)
   );
   const provenance = input.provenance.get(name) ?? {
     source: "local",
@@ -16808,7 +18303,7 @@ async function readSkillMetadata(input) {
     enabled: !input.disabled.has(name),
     source: provenance.source,
     trust: provenance.trust,
-    relativePath: path19.relative(input.skillsRoot, skillDir)
+    relativePath: path20.relative(input.skillsRoot, skillDir)
   };
 }
 function parseSkillDocument(raw) {
@@ -16821,7 +18316,7 @@ function parseSkillDocument(raw) {
   }
   try {
     return {
-      frontmatter: toRecord14(YAML5.parse(match[1] ?? "")),
+      frontmatter: toRecord15(YAML5.parse(match[1] ?? "")),
       body: content.slice(match[0].length)
     };
   } catch {
@@ -16829,8 +18324,8 @@ function parseSkillDocument(raw) {
   }
 }
 function categoryFromPath(skillsRoot, skillFile) {
-  const relative = path19.relative(skillsRoot, skillFile);
-  const parts = relative.split(path19.sep).filter(Boolean);
+  const relative = path20.relative(skillsRoot, skillFile);
+  const parts = relative.split(path20.sep).filter(Boolean);
   return parts.length >= 3 ? parts[0] : null;
 }
 function firstBodyDescription(body) {
@@ -16853,8 +18348,8 @@ function normalizeDescription(value) {
   return `${description.slice(0, MAX_DESCRIPTION_LENGTH - 3)}...`;
 }
 async function readDisabledSkillNames(configPath) {
-  const raw = await readFile14(configPath, "utf8").catch((error) => {
-    if (isNodeError15(error, "ENOENT")) {
+  const raw = await readFile15(configPath, "utf8").catch((error) => {
+    if (isNodeError16(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -16862,8 +18357,8 @@ async function readDisabledSkillNames(configPath) {
   if (!raw.trim()) {
     return /* @__PURE__ */ new Set();
   }
-  const config = toRecord14(YAML5.parse(raw));
-  const skills = toRecord14(config.skills);
+  const config = toRecord15(YAML5.parse(raw));
+  const skills = toRecord15(config.skills);
   return new Set(readStringList3(skills.disabled));
 }
 async function readSkillProvenance(root) {
@@ -16877,9 +18372,9 @@ async function readSkillProvenance(root) {
   return provenance;
 }
 async function readBundledSkillNames(root) {
-  const raw = await readFile14(path19.join(root, ".bundled_manifest"), "utf8").catch(
+  const raw = await readFile15(path20.join(root, ".bundled_manifest"), "utf8").catch(
     (error) => {
-      if (isNodeError15(error, "ENOENT")) {
+      if (isNodeError16(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -16900,9 +18395,9 @@ async function readBundledSkillNames(root) {
   return names;
 }
 async function readHubInstalledSkills(root) {
-  const raw = await readFile14(path19.join(root, ".hub", "lock.json"), "utf8").catch(
+  const raw = await readFile15(path20.join(root, ".hub", "lock.json"), "utf8").catch(
     (error) => {
-      if (isNodeError15(error, "ENOENT")) {
+      if (isNodeError16(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -16913,17 +18408,17 @@ async function readHubInstalledSkills(root) {
   }
   let lock;
   try {
-    lock = toRecord14(JSON.parse(raw));
+    lock = toRecord15(JSON.parse(raw));
   } catch {
     return /* @__PURE__ */ new Map();
   }
-  const installed = toRecord14(lock.installed);
+  const installed = toRecord15(lock.installed);
   const result = /* @__PURE__ */ new Map();
   for (const [name, rawEntry] of Object.entries(installed)) {
-    const entry = toRecord14(rawEntry);
+    const entry = toRecord15(rawEntry);
     result.set(normalizeSkillName(name), {
-      source: readString15(entry.source) ?? "hub",
-      trust: readString15(entry.trust_level) ?? null
+      source: readString16(entry.source) ?? "hub",
+      trust: readString16(entry.trust_level) ?? null
     });
   }
   return result;
@@ -16972,9 +18467,9 @@ function compareCategoryNames(left, right) {
   return left.localeCompare(right);
 }
 async function readHermesConfigDocument2(configPath) {
-  const existingRaw = await readFile14(configPath, "utf8").catch(
+  const existingRaw = await readFile15(configPath, "utf8").catch(
     (error) => {
-      if (isNodeError15(error, "ENOENT")) {
+      if (isNodeError16(error, "ENOENT")) {
         return null;
       }
       throw error;
@@ -16983,13 +18478,13 @@ async function readHermesConfigDocument2(configPath) {
   const document = existingRaw ? YAML5.parseDocument(existingRaw) : new YAML5.Document({});
   return {
     document,
-    config: toRecord14(document.toJSON()),
+    config: toRecord15(document.toJSON()),
     existingRaw
   };
 }
 async function writeHermesConfigDocument2(input) {
   const backupPath = input.existingRaw ? `${input.configPath}.bak.${Date.now()}` : null;
-  await mkdir13(path19.dirname(input.configPath), { recursive: true, mode: 448 });
+  await mkdir13(path20.dirname(input.configPath), { recursive: true, mode: 448 });
   if (backupPath) {
     await copyFile4(input.configPath, backupPath);
   }
@@ -17005,21 +18500,21 @@ function readStringList3(value) {
   }
   return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
 }
-function readString15(value) {
+function readString16(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function toRecord14(value) {
+function toRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 function ensureRecord3(target, key) {
-  const current = toRecord14(target[key]);
+  const current = toRecord15(target[key]);
   if (current === target[key]) {
     return current;
   }
   target[key] = current;
   return current;
 }
-function isNodeError15(error, code) {
+function isNodeError16(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 
@@ -17034,7 +18529,7 @@ function registerProfileSkillRoutes(router, options) {
   router.patch("/api/v1/profiles/:name/skills/:skillName", async (ctx) => {
     await authenticateRequest(ctx, paths);
     const body = await readJsonBody(ctx.req);
-    const enabled = readBoolean(body.enabled);
+    const enabled = readBoolean2(body.enabled);
     if (enabled === void 0) {
       throw new LinkHttpError(
         400,
@@ -17078,22 +18573,18 @@ function registerProfileRoutes(router, options) {
     await authenticateRequest(ctx, paths);
     ctx.respond = false;
     const response = ctx.res;
-    response.statusCode = 200;
-    response.setHeader("content-type", "text/event-stream; charset=utf-8");
-    response.setHeader("cache-control", "no-store");
-    response.setHeader("connection", "keep-alive");
+    let unsubscribe = () => {
+    };
+    beginSseStream(ctx.req, response, {
+      onClose: () => unsubscribe()
+    });
     writeProfileCreationSseEvent(
       response,
       await readHermesProfileCreationStatus(paths)
     );
-    const unsubscribe = subscribeHermesProfileCreationStatus((status) => {
+    unsubscribe = subscribeHermesProfileCreationStatus((status) => {
       writeProfileCreationSseEvent(response, status);
     });
-    const cleanup = () => {
-      unsubscribe();
-      response.end();
-    };
-    ctx.req.on("close", cleanup);
   });
   router.get("/api/v1/profiles/:name/status", async (ctx) => {
     await authenticateRequest(ctx, paths);
@@ -17309,10 +18800,10 @@ function isProfileAvatarUrl(value) {
   return isHttpUrl(value) || /^data:image\/[a-z0-9.+-]+;base64,/iu.test(value);
 }
 function writeProfileCreationSseEvent(response, status) {
-  response.write("event: profile.creation.status\n");
-  response.write(`data: ${JSON.stringify(status)}
-
-`);
+  writeJsonSseEvent(response, {
+    event: "profile.creation.status",
+    data: status
+  });
 }
 
 // src/http/routes/runs.ts
@@ -17322,7 +18813,7 @@ function registerRunRoutes(router, options) {
   router.post("/api/v1/runs", async (ctx) => {
     await authenticateRequest(ctx, paths);
     const body = await readJsonBody(ctx.req);
-    const input = readString13(body, "input");
+    const input = readString14(body, "input");
     if (!input) {
       throw new LinkHttpError(400, "run_input_required", "input is required");
     }
@@ -17330,11 +18821,11 @@ function registerRunRoutes(router, options) {
     ctx.body = await createHermesRun(
       {
         input,
-        instructions: readString13(body, "instructions") ?? void 0,
+        instructions: readString14(body, "instructions") ?? void 0,
         conversation_history: readConversationHistory(
           body.conversation_history ?? body.conversationHistory
         ),
-        session_id: readString13(body, "session_id") ?? readString13(body, "sessionId") ?? void 0
+        session_id: readString14(body, "session_id") ?? readString14(body, "sessionId") ?? void 0
       },
       { logger, profileName: readOptionalProfileName(body) }
     );
@@ -17505,8 +18996,8 @@ function readModelList(payload) {
 // src/hermes/updates.ts
 import { EventEmitter as EventEmitter3 } from "events";
 import { spawn as spawn3 } from "child_process";
-import { mkdir as mkdir14, readFile as readFile15, rm as rm8 } from "fs/promises";
-import path20 from "path";
+import { mkdir as mkdir14, readFile as readFile16, rm as rm8 } from "fs/promises";
+import path21 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;
@@ -17727,24 +19218,24 @@ async function readRemoteRelease(options, now) {
   }
 }
 function normalizeServerReleaseSnapshot(payload) {
-  const snapshot = toRecord15(payload);
+  const snapshot = toRecord16(payload);
   const remote = toNullableRecord(snapshot.remote);
   return {
     remote: remote ? normalizeServerRelease(remote) : null,
-    cacheState: readString16(snapshot, "cache_state") ?? readString16(snapshot, "cacheState"),
-    issue: readString16(snapshot, "issue")
+    cacheState: readString17(snapshot, "cache_state") ?? readString17(snapshot, "cacheState"),
+    issue: readString17(snapshot, "issue")
   };
 }
 function normalizeServerRelease(payload) {
-  const tag = readString16(payload, "tag");
-  const name = readString16(payload, "name");
+  const tag = readString17(payload, "tag");
+  const name = readString17(payload, "name");
   return {
-    version: readString16(payload, "version") ?? extractSemver(name) ?? extractTagSemver(tag),
+    version: readString17(payload, "version") ?? extractSemver(name) ?? extractTagSemver(tag),
     tag,
     name,
-    releaseUrl: readString16(payload, "releaseUrl") ?? readString16(payload, "release_url"),
-    publishedAt: readString16(payload, "publishedAt") ?? readString16(payload, "published_at"),
-    fetchedAt: readString16(payload, "fetchedAt") ?? readString16(payload, "fetched_at") ?? (/* @__PURE__ */ new Date()).toISOString()
+    releaseUrl: readString17(payload, "releaseUrl") ?? readString17(payload, "release_url"),
+    publishedAt: readString17(payload, "publishedAt") ?? readString17(payload, "published_at"),
+    fetchedAt: readString17(payload, "fetchedAt") ?? readString17(payload, "fetched_at") ?? (/* @__PURE__ */ new Date()).toISOString()
   };
 }
 async function readReleaseCache(paths) {
@@ -17763,7 +19254,7 @@ async function writeUpdateState(paths, state) {
   await writeJsonFile(updateStatePath(paths), state);
 }
 async function readUpdateLogLines(paths) {
-  const raw = await readFile15(updateLogPath(paths), "utf8").catch(() => "");
+  const raw = await readFile16(updateLogPath(paths), "utf8").catch(() => "");
   if (!raw.trim()) {
     return [];
   }
@@ -17772,13 +19263,13 @@ async function readUpdateLogLines(paths) {
   );
 }
 function releaseCachePath(paths) {
-  return path20.join(paths.indexesDir, "hermes-release-check.json");
+  return path21.join(paths.indexesDir, "hermes-release-check.json");
 }
 function updateStatePath(paths) {
-  return path20.join(paths.runDir, "hermes-update-state.json");
+  return path21.join(paths.runDir, "hermes-update-state.json");
 }
 function updateLogPath(paths) {
-  return path20.join(paths.logsDir, UPDATE_LOG_FILE);
+  return path21.join(paths.logsDir, UPDATE_LOG_FILE);
 }
 async function clearUpdateLogFiles(paths) {
   const primary = updateLogPath(paths);
@@ -17816,7 +19307,7 @@ function compareSemver2(left, right) {
   }
   return 0;
 }
-function toRecord15(value) {
+function toRecord16(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function toNullableRecord(value) {
@@ -17862,7 +19353,7 @@ function isRecentRunningState2(state) {
   const startedAt = Date.parse(state.started_at);
   return Number.isFinite(startedAt) && Date.now() - startedAt < 3e4;
 }
-function readString16(payload, key) {
+function readString17(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
@@ -17870,13 +19361,13 @@ function readString16(payload, key) {
 // src/link/updates.ts
 import { spawn as spawn5 } from "child_process";
 import { EventEmitter as EventEmitter4 } from "events";
-import { mkdir as mkdir17, readFile as readFile17, rm as rm11 } from "fs/promises";
-import path22 from "path";
+import { mkdir as mkdir17, readFile as readFile18, rm as rm11 } from "fs/promises";
+import path23 from "path";
 
 // src/daemon/process.ts
 import { spawn as spawn4 } from "child_process";
-import { mkdir as mkdir16, readFile as readFile16, rm as rm10 } from "fs/promises";
-import path21 from "path";
+import { mkdir as mkdir16, readFile as readFile17, rm as rm10 } from "fs/promises";
+import path22 from "path";
 
 // src/daemon/service.ts
 import { createServer } from "http";
@@ -18054,7 +19545,7 @@ async function handleFrame(socket, raw, localPort, abortControllers) {
 // src/runtime/system-info.ts
 import { execFileSync } from "child_process";
 import { readFileSync } from "fs";
-import os5 from "os";
+import os6 from "os";
 function readLinkSystemInfo() {
   const platform = process.platform;
   const hostname = readHostname(platform);
@@ -18093,7 +19584,7 @@ function readHostname(platform) {
       return computerName;
     }
   }
-  return normalizeText(os5.hostname());
+  return normalizeText(os6.hostname());
 }
 function readOsLabel(platform) {
   if (platform === "darwin") {
@@ -18101,12 +19592,12 @@ function readOsLabel(platform) {
     return version ? `macOS ${version}` : "macOS";
   }
   if (platform === "linux") {
-    return readLinuxOsRelease() ?? `Linux ${os5.release()}`;
+    return readLinuxOsRelease() ?? `Linux ${os6.release()}`;
   }
   if (platform === "win32") {
-    return `Windows ${os5.release()}`;
+    return `Windows ${os6.release()}`;
   }
-  return `${os5.type()} ${os5.release()}`.trim();
+  return `${os6.type()} ${os6.release()}`.trim();
 }
 function readLinuxOsRelease() {
   for (const file of ["/etc/os-release", "/usr/lib/os-release"]) {
@@ -18153,11 +19644,11 @@ function truncateText(value, maxLength) {
 }
 
 // src/topology/network.ts
-import os7 from "os";
+import os8 from "os";
 
 // src/topology/environment.ts
 import { existsSync, readFileSync as readFileSync2 } from "fs";
-import os6 from "os";
+import os7 from "os";
 function detectRuntimeEnvironment(env = process.env) {
   if (isWsl(env)) {
     return {
@@ -18186,7 +19677,7 @@ function isWsl(env) {
   if (env.WSL_DISTRO_NAME || env.WSL_INTEROP) {
     return true;
   }
-  const release = os6.release().toLowerCase();
+  const release = os7.release().toLowerCase();
   return release.includes("microsoft") || release.includes("wsl");
 }
 function isContainer(env) {
@@ -18231,7 +19722,7 @@ async function discoverRouteCandidates(options) {
   };
 }
 function discoverLanIps() {
-  return discoverLanIpsFromInterfaces(os7.networkInterfaces());
+  return discoverLanIpsFromInterfaces(os8.networkInterfaces());
 }
 function discoverLanIpsFromInterfaces(interfaces) {
   const result = /* @__PURE__ */ new Set();
@@ -18724,6 +20215,33 @@ function startCronDeliveryScheduler(options) {
     }
   };
 }
+function startHermesSessionSyncScheduler(options) {
+  let running = false;
+  const syncSessions = async () => {
+    if (running) {
+      return;
+    }
+    running = true;
+    try {
+      await options.conversations.syncHermesSessions();
+    } catch (error) {
+      void options.logger.warn("hermes_session_sync_failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      running = false;
+    }
+  };
+  const timer = setInterval(() => {
+    void syncSessions();
+  }, options.intervalMs ?? 10 * 60 * 1e3);
+  timer.unref?.();
+  return {
+    close() {
+      clearInterval(timer);
+    }
+  };
+}
 
 // src/daemon/service.ts
 async function startLinkService(options = {}) {
@@ -18744,11 +20262,21 @@ async function startLinkService(options = {}) {
   }
   const conversations = new ConversationService(paths, logger);
   await conversations.rebuildStatisticsIndex();
+  const triggerHermesSessionSync = () => {
+    void conversations.syncHermesSessions().catch((error) => {
+      void logger.warn("hermes_session_sync_failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+  };
   const app = await createApp({
     paths,
     logger,
     conversations,
-    onPairingClaimed: options.onPairingClaimed
+    onPairingClaimed: async () => {
+      triggerHermesSessionSync();
+      await options.onPairingClaimed?.();
+    }
   });
   const server = createServer(app.callback());
   try {
@@ -18768,11 +20296,16 @@ async function startLinkService(options = {}) {
     port: config.port,
     link_id: identity?.link_id ?? null
   });
+  triggerHermesSessionSync();
   const scheduler = startCronDeliveryScheduler({
     paths,
     conversations,
     logger
   });
+  const hermesSessionSyncScheduler = startHermesSessionSyncScheduler({
+    conversations,
+    logger
+  });
   let relay = null;
   if (identity?.link_id) {
     relay = connectRelayControl({
@@ -18805,6 +20338,7 @@ async function startLinkService(options = {}) {
   return {
     async close() {
       scheduler.close();
+      hermesSessionSyncScheduler.close();
       lanIpMonitor.close();
       relay?.close();
       await closeServer(server);
@@ -18917,7 +20451,7 @@ async function runDaemonSupervisor(paths = resolveRuntimePaths()) {
   await mkdir16(paths.logsDir, { recursive: true, mode: 448 });
   const log = createRotatingTextLogWriter({
     paths,
-    fileName: path21.basename(daemonLogFile(paths))
+    fileName: path22.basename(daemonLogFile(paths))
   });
   const scriptPath = currentCliScriptPath();
   const child = spawn4(process.execPath, [scriptPath, "daemon", "--foreground"], {
@@ -19046,7 +20580,7 @@ function currentCliScriptPath() {
   return process.argv[1];
 }
 async function readPid(filePath) {
-  const raw = await readFile16(filePath, "utf8").catch(() => null);
+  const raw = await readFile17(filePath, "utf8").catch(() => null);
   if (!raw) {
     return null;
   }
@@ -19372,21 +20906,21 @@ async function readRemoteLinkPolicy(options) {
   }
 }
 function normalizeServerSnapshot(payload) {
-  const snapshot = toRecord16(payload);
+  const snapshot = toRecord17(payload);
   const policy = toNullableRecord2(snapshot.policy);
   if (!policy) {
     return {
       remote: null,
-      issue: readString17(snapshot, "issue")
+      issue: readString18(snapshot, "issue")
     };
   }
   const release = toNullableRecord2(snapshot.release);
-  const currentVersion = readString17(policy, "current_version") ?? readString17(policy, "currentVersion");
-  const minSafeVersion = readString17(policy, "min_safe_version") ?? readString17(policy, "minSafeVersion");
+  const currentVersion = readString18(policy, "current_version") ?? readString18(policy, "currentVersion");
+  const minSafeVersion = readString18(policy, "min_safe_version") ?? readString18(policy, "minSafeVersion");
   if (!currentVersion) {
     return {
       remote: null,
-      issue: readString17(snapshot, "issue")
+      issue: readString18(snapshot, "issue")
     };
   }
   return {
@@ -19394,10 +20928,10 @@ function normalizeServerSnapshot(payload) {
       current_version: currentVersion,
       min_safe_version: minSafeVersion,
       target_version: currentVersion,
-      release_url: release ? readString17(release, "release_url") ?? readString17(release, "releaseUrl") : null,
-      published_at: release ? readString17(release, "published_at") ?? readString17(release, "publishedAt") : null
+      release_url: release ? readString18(release, "release_url") ?? readString18(release, "releaseUrl") : null,
+      published_at: release ? readString18(release, "published_at") ?? readString18(release, "publishedAt") : null
     },
-    issue: readString17(snapshot, "issue")
+    issue: readString18(snapshot, "issue")
   };
 }
 async function fetchCurrentLinkReleaseFromServer(options, fetcher) {
@@ -19447,7 +20981,7 @@ async function writeUpdateState2(paths, state) {
   await writeJsonFile(updateStatePath2(paths), state);
 }
 async function readUpdateLogLines2(paths) {
-  const raw = await readFile17(updateLogPath2(paths), "utf8").catch(() => "");
+  const raw = await readFile18(updateLogPath2(paths), "utf8").catch(() => "");
   if (!raw.trim()) {
     return [];
   }
@@ -19456,10 +20990,10 @@ async function readUpdateLogLines2(paths) {
   );
 }
 function updateStatePath2(paths) {
-  return path22.join(paths.runDir, "link-update-state.json");
+  return path23.join(paths.runDir, "link-update-state.json");
 }
 function updateLogPath2(paths) {
-  return path22.join(paths.logsDir, UPDATE_LOG_FILE2);
+  return path23.join(paths.logsDir, UPDATE_LOG_FILE2);
 }
 async function clearUpdateLogFiles2(paths) {
   const primary = updateLogPath2(paths);
@@ -19511,19 +21045,19 @@ function isProcessAlive4(pid) {
     return false;
   }
 }
-function toRecord16(value) {
+function toRecord17(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function toNullableRecord2(value) {
   return typeof value === "object" && value !== null ? value : null;
 }
-function readString17(payload, key) {
+function readString18(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 
 // src/pairing/pairing.ts
-import path23 from "path";
+import path24 from "path";
 import { rm as rm12 } from "fs/promises";
 
 // src/relay/bootstrap.ts
@@ -19799,8 +21333,8 @@ async function loadRequiredIdentity2(paths) {
   }
   return identity;
 }
-async function postServerJson(serverBaseUrl, path24, body) {
-  const response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path24}`, {
+async function postServerJson(serverBaseUrl, path25, body) {
+  const response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path25}`, {
     method: "POST",
     headers: {
       accept: "application/json",
@@ -19840,8 +21374,8 @@ function pairingErrorSnapshot(stage, error) {
     occurred_at: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-async function patchServerJson(serverBaseUrl, path24, token, body) {
-  const response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path24}`, {
+async function patchServerJson(serverBaseUrl, path25, token, body) {
+  const response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path25}`, {
     method: "PATCH",
     headers: {
       accept: "application/json",
@@ -19872,10 +21406,10 @@ function readErrorMessage5(payload) {
   return typeof message === "string" ? message : null;
 }
 function pairingClaimPath(sessionId, paths) {
-  return path23.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.claimed.json`);
+  return path24.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.claimed.json`);
 }
 function pairingSessionPath(sessionId, paths) {
-  return path23.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.json`);
+  return path24.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);
@@ -19946,8 +21480,8 @@ function registerSystemRoutes(router, options) {
   });
   router.post("/api/v1/pairing/claim", async (ctx) => {
     const body = await readJsonBody(ctx.req);
-    const sessionId = readString13(body, "session_id") ?? readString13(body, "sessionId");
-    const claimToken = readString13(body, "claim_token") ?? readString13(body, "claimToken");
+    const sessionId = readString14(body, "session_id") ?? readString14(body, "sessionId");
+    const claimToken = readString14(body, "claim_token") ?? readString14(body, "claimToken");
     if (!sessionId || !claimToken) {
       throw new LinkHttpError(
         400,
@@ -19958,10 +21492,10 @@ function registerSystemRoutes(router, options) {
     const claimed = await claimPairing({
       sessionId,
       claimToken,
-      deviceLabel: readString13(body, "device_label") ?? readString13(body, "deviceLabel") ?? "HermesPilot App",
-      devicePlatform: readString13(body, "device_platform") ?? readString13(body, "devicePlatform") ?? "unknown",
-      deviceModel: readString13(body, "device_model") ?? readString13(body, "deviceModel"),
-      appInstanceId: readString13(body, "app_instance_id") ?? readString13(body, "appInstanceId"),
+      deviceLabel: readString14(body, "device_label") ?? readString14(body, "deviceLabel") ?? "HermesPilot App",
+      devicePlatform: readString14(body, "device_platform") ?? readString14(body, "devicePlatform") ?? "unknown",
+      deviceModel: readString14(body, "device_model") ?? readString14(body, "deviceModel"),
+      appInstanceId: readString14(body, "app_instance_id") ?? readString14(body, "appInstanceId"),
       paths
     });
     ctx.body = claimed;
@@ -20036,9 +21570,9 @@ function registerSystemRoutes(router, options) {
     const body = await readJsonBody(ctx.req);
     const session = await createDeviceSession(
       {
-        label: readString13(body, "device_label") ?? readString13(body, "deviceLabel") ?? "HermesPilot App",
-        platform: readString13(body, "device_platform") ?? readString13(body, "devicePlatform") ?? "unknown",
-        model: readString13(body, "device_model") ?? readString13(body, "deviceModel"),
+        label: readString14(body, "device_label") ?? readString14(body, "deviceLabel") ?? "HermesPilot App",
+        platform: readString14(body, "device_platform") ?? readString14(body, "devicePlatform") ?? "unknown",
+        model: readString14(body, "device_model") ?? readString14(body, "deviceModel"),
         appInstanceId: auth.appInstanceId
       },
       paths
@@ -20067,7 +21601,7 @@ function registerSystemRoutes(router, options) {
   });
   router.post("/api/v1/auth/refresh", async (ctx) => {
     const body = await readJsonBody(ctx.req);
-    const refreshToken = readString13(body, "refresh_token") ?? readString13(body, "refreshToken");
+    const refreshToken = readString14(body, "refresh_token") ?? readString14(body, "refreshToken");
     if (!refreshToken) {
       throw new LinkHttpError(
         400,
@@ -20078,10 +21612,10 @@ function registerSystemRoutes(router, options) {
     const session = await refreshDeviceSession(
       refreshToken,
       {
-        appInstanceId: readString13(body, "app_instance_id") ?? readString13(body, "appInstanceId"),
-        label: readString13(body, "device_label") ?? readString13(body, "deviceLabel"),
-        platform: readString13(body, "device_platform") ?? readString13(body, "devicePlatform"),
-        model: readString13(body, "device_model") ?? readString13(body, "deviceModel")
+        appInstanceId: readString14(body, "app_instance_id") ?? readString14(body, "appInstanceId"),
+        label: readString14(body, "device_label") ?? readString14(body, "deviceLabel"),
+        platform: readString14(body, "device_platform") ?? readString14(body, "devicePlatform"),
+        model: readString14(body, "device_model") ?? readString14(body, "deviceModel")
       },
       paths
     );
@@ -20100,7 +21634,7 @@ function registerSystemRoutes(router, options) {
   });
   router.post("/api/v1/auth/logout", async (ctx) => {
     const body = await readJsonBody(ctx.req);
-    const refreshToken = readString13(body, "refresh_token") ?? readString13(body, "refreshToken");
+    const refreshToken = readString14(body, "refresh_token") ?? readString14(body, "refreshToken");
     if (refreshToken) {
       await revokeDeviceRefreshToken(refreshToken, paths);
     }
@@ -20325,7 +21859,7 @@ function registerSystemRoutes(router, options) {
   router.patch("/api/v1/devices/:deviceId", async (ctx) => {
     const auth = await authenticateRequest(ctx, paths);
     const body = await readJsonBody(ctx.req);
-    const label = readString13(body, "label") ?? readString13(body, "device_label");
+    const label = readString14(body, "label") ?? readString14(body, "device_label");
     if (!label) {
       throw new LinkHttpError(
         400,
@@ -20365,11 +21899,11 @@ async function readActiveCronJobCount(profiles, logger) {
   }, 0);
 }
 function isActiveCronJob(job) {
-  const enabled = readBoolean(job.enabled) ?? true;
+  const enabled = readBoolean2(job.enabled) ?? true;
   if (!enabled) {
     return false;
   }
-  const state = readString13(job, "state")?.toLowerCase();
+  const state = readString14(job, "state")?.toLowerCase();
   return !["paused", "disabled", "completed", "deleted"].includes(state ?? "");
 }
 function filterLogsWithinHours(logs, hours, now = Date.now()) {
@@ -20421,26 +21955,22 @@ function registerHermesUpdateRoutes(router, options) {
     await authenticateRequest(ctx, paths);
     ctx.respond = false;
     const response = ctx.res;
-    response.statusCode = 200;
-    response.setHeader("content-type", "text/event-stream; charset=utf-8");
-    response.setHeader("cache-control", "no-store");
-    response.setHeader("connection", "keep-alive");
+    let unsubscribe = () => {
+    };
+    beginSseStream(ctx.req, response, {
+      onClose: () => unsubscribe()
+    });
     writeUpdateSseEvent(response, await readHermesUpdateStatus(paths));
-    const unsubscribe = subscribeHermesUpdateStatus((status) => {
+    unsubscribe = subscribeHermesUpdateStatus((status) => {
       writeUpdateSseEvent(response, status);
     });
-    const cleanup = () => {
-      unsubscribe();
-      response.end();
-    };
-    ctx.req.on("close", cleanup);
   });
 }
 function writeUpdateSseEvent(response, status) {
-  response.write("event: hermes.update.status\n");
-  response.write(`data: ${JSON.stringify(status)}
-
-`);
+  writeJsonSseEvent(response, {
+    event: "hermes.update.status",
+    data: status
+  });
 }
 
 // src/http/routes/link-updates.ts
@@ -20463,33 +21993,29 @@ function registerLinkUpdateRoutes(router, options) {
     ctx.body = await startLinkUpdate({
       paths,
       logger,
-      targetVersion: readString13(body, "target_version") ?? readString13(body, "targetVersion")
+      targetVersion: readString14(body, "target_version") ?? readString14(body, "targetVersion")
     });
   });
   router.get("/api/v1/link/update/events", async (ctx) => {
     await authenticateRequest(ctx, paths);
     ctx.respond = false;
     const response = ctx.res;
-    response.statusCode = 200;
-    response.setHeader("content-type", "text/event-stream; charset=utf-8");
-    response.setHeader("cache-control", "no-store");
-    response.setHeader("connection", "keep-alive");
+    let unsubscribe = () => {
+    };
+    beginSseStream(ctx.req, response, {
+      onClose: () => unsubscribe()
+    });
     writeUpdateSseEvent2(response, await readLinkUpdateStatus(paths));
-    const unsubscribe = subscribeLinkUpdateStatus((status) => {
+    unsubscribe = subscribeLinkUpdateStatus((status) => {
       writeUpdateSseEvent2(response, status);
     });
-    const cleanup = () => {
-      unsubscribe();
-      response.end();
-    };
-    ctx.req.on("close", cleanup);
   });
 }
 function writeUpdateSseEvent2(response, status) {
-  response.write("event: link.update.status\n");
-  response.write(`data: ${JSON.stringify(status)}
-
-`);
+  writeJsonSseEvent(response, {
+    event: "link.update.status",
+    data: status
+  });
 }
 
 // src/http/routes/pairing.ts
@@ -20497,7 +22023,7 @@ import QRCode from "qrcode";
 function registerPairingRoutes(router, options) {
   const { paths } = options;
   router.get("/pair", async (ctx) => {
-    const sessionId = readString13(ctx.query, "session_id");
+    const sessionId = readString14(ctx.query, "session_id");
     if (!sessionId) {
       throw new LinkHttpError(400, "pairing_session_required", "session_id is required");
     }
@@ -20522,7 +22048,7 @@ function registerPairingRoutes(router, options) {
     ctx.body = page;
   });
   router.get("/api/v1/pairing/session", async (ctx) => {
-    const sessionId = readString13(ctx.query, "session_id");
+    const sessionId = readString14(ctx.query, "session_id");
     if (!sessionId) {
       throw new LinkHttpError(400, "pairing_session_required", "session_id is required");
     }
@@ -20926,7 +22452,7 @@ function registerInternalRoutes(router, options) {
   router.post("/internal/deliver", async (ctx) => {
     assertLoopbackRequest(ctx.req);
     const body = await readJsonBody(ctx.req);
-    const stagingDir = readString13(body, "staging_dir") ?? readString13(body, "stagingDir");
+    const stagingDir = readString14(body, "staging_dir") ?? readString14(body, "stagingDir");
     if (!stagingDir) {
       throw new LinkHttpError(
         400,