@hermespilot/link 0.3.4 → 0.3.5

package/dist/{chunk-FPMMWYXK.js → chunk-ZQO7TU7G.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.5";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -8485,40 +8485,1198 @@ var ConversationStore = class {
     }
     return manifest;
   }
-  async isConversationActive(conversationId) {
-    const manifest = await this.readManifest(conversationId).catch(() => null);
-    return manifest?.status === "active";
+  async isConversationActive(conversationId) {
+    const manifest = await this.readManifest(conversationId).catch(() => null);
+    return manifest?.status === "active";
+  }
+  removeConversationAttachments(conversationId) {
+    return rm5(path12.join(this.conversationDir(conversationId), "attachments"), {
+      recursive: true,
+      force: true
+    });
+  }
+  conversationDir(conversationId) {
+    assertValidConversationId(conversationId);
+    return path12.join(this.paths.conversationsDir, conversationId);
+  }
+  manifestPath(conversationId) {
+    return path12.join(this.conversationDir(conversationId), "manifest.json");
+  }
+  snapshotPath(conversationId) {
+    return path12.join(this.conversationDir(conversationId), "snapshot.json");
+  }
+  eventsPath(conversationId) {
+    return path12.join(this.conversationDir(conversationId), "events.ndjson");
+  }
+};
+function createEmptySnapshot2() {
+  return { schema_version: 1, messages: [], runs: [] };
+}
+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 readdir5, readFile as readFile8, stat as stat7 } from "fs/promises";
+import { createRequire as createRequire3 } from "module";
+import os4 from "os";
+import path13 from "path";
+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_v2";
+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 = path13.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 });
+    }
+  }
+  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,
+        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,
+      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 importHermesSession(input) {
+  const { paths, store, candidate, existingHermesSessionIds } = input;
+  const profile = await resolveConversationProfileTarget(
+    paths,
+    candidate.profileName
+  );
+  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 = readString8(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 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 snapshot.messages) {
+    await store.appendEvent(conversationId, {
+      type: "message.created",
+      message_id: message.id,
+      payload: { message, imported_from: "hermes" },
+      raw: message.raw
+    });
+  }
+  const stats = buildConversationStats(
+    await store.readManifest(conversationId),
+    snapshot
+  );
+  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)
+      ]
+    };
+    const stats = buildConversationStats(manifest, nextSnapshot);
+    await input.store.writeSnapshot(conversationId, nextSnapshot);
+    await input.store.writeManifest({ ...manifest, stats });
+    await upsertConversationStats(
+      input.paths,
+      toStatsIndexRecord({ ...manifest, stats }, stats)
+    );
+    changed = true;
+  }
+  return changed;
+}
+function collectImportedHermesPrefix(snapshot) {
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  let needsProjectionVersion = false;
+  let hasToolMetadata = 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;
+      }
+    }
+    for (const event of message.agent_events ?? []) {
+      for (const row of readHermesRowsFromAgentEvent(event)) {
+        appendHermesRowOnce(rows, seen, row);
+        if (hasHermesToolMetadata(row)) {
+          hasToolMetadata = true;
+        }
+      }
+    }
+  }
+  if (rows.length === 0 || endIndex === 0) {
+    return null;
+  }
+  return {
+    endIndex,
+    messages: rows,
+    needsUpgrade: needsProjectionVersion && hasToolMetadata
+  };
+}
+function isHermesImportedMessage(message) {
+  return message.hermes?.imported_from === "hermes" || message.raw?.format === "hermes-message" || message.raw?.format === "hermes-message-group";
+}
+function readHermesRowsFromAgentEvent(event) {
+  if (event.raw?.format !== "hermes-message" && event.raw?.format !== "hermes-message-group") {
+    return [];
+  }
+  const payload = toRecord7(event.raw.payload);
+  const message = toRecord7(payload.message);
+  if (normalizeMessageRole(readString8(message, "role") ?? void 0) === "tool") {
+    return [message];
+  }
+  return readHermesRawMessageRows(event.raw).filter(
+    (row) => Boolean(readString8(row, "role"))
+  );
+}
+function appendHermesRowOnce(rows, seen, row) {
+  const key = hermesRowKey(row, rows.length);
+  if (seen.has(key)) {
+    return;
+  }
+  seen.add(key);
+  rows.push(row);
+}
+function hermesRowKey(row, fallbackIndex) {
+  if (row.id !== void 0 && row.id !== null) {
+    return `id:${row.id}`;
+  }
+  return `fallback:${fallbackIndex}:${row.role ?? ""}:${row.timestamp ?? ""}:${normalizeContent(row.content)}`;
+}
+function hasHermesToolMetadata(row) {
+  return normalizeMessageRole(row.role) === "tool" || readHermesToolCalls(row).length > 0 || Boolean(readString8(row, "tool_call_id")) || Boolean(readString8(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 = readString8(input.toolMessage, "tool_call_id");
+  const toolName = readString8(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 = toRecord7(value);
+  if (Object.keys(record).length === 0) {
+    return null;
+  }
+  const fn = toRecord7(record.function);
+  const id = readString8(record, "id") ?? readString8(record, "call_id") ?? readString8(record, "tool_call_id") ?? readString8(fn, "id") ?? void 0;
+  const name = readString8(fn, "name") ?? readString8(record, "name") ?? readString8(record, "tool_name") ?? readString8(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 = readString8(input.sourceMessage, "tool_call_id") ?? input.pending?.toolCall.id;
+  const toolName = readString8(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 = path13.join(os4.homedir(), ".hermes", "profiles");
+  const entries = await readdir5(profilesDir, { withFileTypes: true }).catch(
+    (error) => {
+      if (isNodeError9(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 = toRecord7(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 = readString8(row, "id");
+    if (!id) {
+      continue;
+    }
+    byId.set(id, row);
+    const parentId = readString8(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 = readString8(row, "id");
+    if (!id || readString8(row, "parent_session_id")) {
+      continue;
+    }
+    let tip = row;
+    const visited = /* @__PURE__ */ new Set([id]);
+    while (readString8(tip, "end_reason") === "compression") {
+      const tipId2 = readString8(tip, "id");
+      if (!tipId2) {
+        break;
+      }
+      const next = (childrenByParent.get(tipId2) ?? []).filter((child) => readString8(child, "id")).sort(
+        (left, right) => (readNumber2(right.last_active) ?? 0) - (readNumber2(left.last_active) ?? 0)
+      )[0];
+      const nextId = next ? readString8(next, "id") : null;
+      if (!next || !nextId || visited.has(nextId)) {
+        break;
+      }
+      tip = next;
+      visited.add(nextId);
+    }
+    const tipId = readString8(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(() => path13.join(profileDir, "sessions"));
+  const transcriptPath = path13.join(sessionsDir, `${sessionId}.jsonl`);
+  const raw = await readFile8(transcriptPath, "utf8").catch((error) => {
+    if (isNodeError9(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 = readString8(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
+  };
+}
+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 readString8(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;
   }
-  removeConversationAttachments(conversationId) {
-    return rm5(path12.join(this.conversationDir(conversationId), "attachments"), {
-      recursive: true,
-      force: true
-    });
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return void 0;
   }
-  conversationDir(conversationId) {
-    assertValidConversationId(conversationId);
-    return path12.join(this.paths.conversationsDir, conversationId);
+}
+function toRecord7(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function isDeletedSession(session) {
+  return readBoolean(session.deleted) || readBoolean(session.is_deleted) || Boolean(readString8(session, "deleted_at")) || ["deleted", "removed"].includes(readString8(session, "status") ?? "");
+}
+function isHiddenSession(session) {
+  const source = readString8(session, "source")?.toLowerCase();
+  const status = readString8(session, "status")?.toLowerCase();
+  const visibility = readString8(session, "visibility")?.toLowerCase();
+  return Boolean(source && HIDDEN_SESSION_SOURCES.has(source)) || readBoolean(session.hidden) || readBoolean(session.archived) || Boolean(readString8(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();
   }
-  manifestPath(conversationId) {
-    return path12.join(this.conversationDir(conversationId), "manifest.json");
+}
+function quoteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+async function isFile(filePath) {
+  return stat7(filePath).then((value) => value.isFile()).catch((error) => {
+    if (isNodeError9(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;
   }
-  snapshotPath(conversationId) {
-    return path12.join(this.conversationDir(conversationId), "snapshot.json");
+  const millis = numeric > 1e10 ? numeric : numeric * 1e3;
+  return new Date(millis).toISOString();
+}
+function readString8(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;
   }
-  eventsPath(conversationId) {
-    return path12.join(this.conversationDir(conversationId), "events.ndjson");
+  if (typeof value === "string") {
+    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
   }
-};
-function createEmptySnapshot2() {
-  return { schema_version: 1, messages: [], runs: [] };
+  return false;
 }
-function isNodeError8(error, code) {
+function isNodeError9(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 
 // src/conversations/delivery-import.ts
-import { lstat, readFile as readFile8, readdir as readdir5, stat as stat7 } from "fs/promises";
-import path13 from "path";
+import { lstat, readFile as readFile9, readdir as readdir6, stat as stat8 } from "fs/promises";
+import path14 from "path";
 var MAX_IMPORTED_BLOB_BYTES = 100 * 1024 * 1024;
 var MAX_MEDIA_IMPORT_FAILURES = 20;
 var MAX_DELIVERY_FILES = 50;
@@ -8589,16 +9747,16 @@ var SUPPORTED_DELIVERY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".m4a"
 ]);
 function resolveDeliveryStagingTarget(paths, stagingDir) {
-  const resolvedDir = path13.resolve(stagingDir);
-  const relative = path13.relative(path13.resolve(paths.conversationsDir), resolvedDir);
-  if (!relative || relative.startsWith("..") || path13.isAbsolute(relative)) {
+  const resolvedDir = path14.resolve(stagingDir);
+  const relative = path14.relative(path14.resolve(paths.conversationsDir), resolvedDir);
+  if (!relative || relative.startsWith("..") || path14.isAbsolute(relative)) {
     throw new LinkHttpError(
       400,
       "delivery_staging_invalid",
       "delivery staging directory must be inside Hermes Link conversations"
     );
   }
-  const segments = relative.split(path13.sep);
+  const segments = relative.split(path14.sep);
   if (segments.length !== 3 || segments[1] !== DELIVERY_STAGING_SEGMENT || !segments[0] || !segments[2]) {
     throw new LinkHttpError(
       400,
@@ -8614,7 +9772,7 @@ function resolveDeliveryStagingTarget(paths, stagingDir) {
 }
 async function collectStagedDeliveryReferences(stagingDir) {
   const directoryStat = await lstat(stagingDir).catch((error) => {
-    if (isNodeError9(error, "ENOENT")) {
+    if (isNodeError10(error, "ENOENT")) {
       throw new LinkHttpError(
         404,
         "delivery_staging_not_found",
@@ -8630,11 +9788,11 @@ async function collectStagedDeliveryReferences(stagingDir) {
       "delivery staging path is not a directory"
     );
   }
-  const entries = await readdir5(stagingDir, { withFileTypes: true });
+  const entries = await readdir6(stagingDir, { withFileTypes: true });
   return entries.filter((entry) => entry.isFile() && !entry.name.startsWith(".")).filter((entry) => isSupportedDeliveryFilename(entry.name)).sort(
     (left, right) => left.name.localeCompare(right.name, "en", { numeric: true })
   ).slice(0, MAX_DELIVERY_FILES).map((entry) => {
-    const sourcePath = path13.join(stagingDir, entry.name);
+    const sourcePath = path14.join(stagingDir, entry.name);
     const mime = inferMimeType(sourcePath);
     return {
       path: sourcePath,
@@ -8713,7 +9871,7 @@ async function importMediaReferencesForMessage(deps, input) {
     };
   }
   assistant.hermes = {
-    ...toRecord7(assistant.hermes),
+    ...toRecord8(assistant.hermes),
     imported_media_source_keys: [...importedSourceKeys],
     media_import_failed_source_keys: [...failedSourceKeys],
     media_import_failures: [...failureRecordsByKey.values()].slice(
@@ -8745,16 +9903,16 @@ async function importMediaReferencesForMessage(deps, input) {
   };
 }
 function readMediaImportFailures(message) {
-  const hermes = toRecord7(message.hermes);
+  const hermes = toRecord8(message.hermes);
   const failures = hermes.media_import_failures;
   if (!Array.isArray(failures)) {
     return [];
   }
   return failures.flatMap((item) => {
-    const record = toRecord7(item);
-    const key = readString8(record, "key");
-    const filename = readString8(record, "filename");
-    const reason = readString8(record, "reason");
+    const record = toRecord8(item);
+    const key = readString9(record, "key");
+    const filename = readString9(record, "filename");
+    const reason = readString9(record, "reason");
     if (!key || !filename || !reason) {
       return [];
     }
@@ -8763,13 +9921,13 @@ function readMediaImportFailures(message) {
         key,
         filename,
         reason,
-        ...readString8(record, "code") ? { code: readString8(record, "code") } : {}
+        ...readString9(record, "code") ? { code: readString9(record, "code") } : {}
       }
     ];
   });
 }
 function readFailedMediaSourceKeys(message) {
-  const hermes = toRecord7(message.hermes);
+  const hermes = toRecord8(message.hermes);
   const keys = hermes.media_import_failed_source_keys;
   if (!Array.isArray(keys)) {
     return /* @__PURE__ */ new Set();
@@ -8794,8 +9952,8 @@ function emptyImportResult(input) {
 }
 async function writeBlobFromFile(deps, conversationId, source) {
   const sourcePath = resolveMediaSourcePath(source.path);
-  const fileStat = await stat7(sourcePath).catch((error) => {
-    if (isNodeError9(error, "ENOENT")) {
+  const fileStat = await stat8(sourcePath).catch((error) => {
+    if (isNodeError10(error, "ENOENT")) {
       throw new LinkHttpError(
         404,
         "media_source_not_found",
@@ -8819,8 +9977,8 @@ async function writeBlobFromFile(deps, conversationId, source) {
     );
   }
   return deps.writeBlob(conversationId, {
-    bytes: await readFile8(sourcePath),
-    filename: path13.basename(sourcePath),
+    bytes: await readFile9(sourcePath),
+    filename: path14.basename(sourcePath),
     mime: source.mime ?? inferMimeType(sourcePath)
   });
 }
@@ -8829,25 +9987,25 @@ function describeMediaImportFailure(reference, sourceKey, error) {
     key: sourceKey,
     filename: sanitizeFilename(reference.path, "attachment"),
     reason: error instanceof Error ? error.message : String(error),
-    ...isNodeError9(error) && error.code ? { code: error.code } : {}
+    ...isNodeError10(error) && error.code ? { code: error.code } : {}
   };
 }
 function isSupportedDeliveryFilename(filename) {
-  return SUPPORTED_DELIVERY_EXTENSIONS.has(path13.extname(filename).toLowerCase());
+  return SUPPORTED_DELIVERY_EXTENSIONS.has(path14.extname(filename).toLowerCase());
 }
-function readString8(payload, key) {
+function readString9(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function toRecord7(value) {
+function toRecord8(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
-function isNodeError9(error, code) {
+function isNodeError10(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";
+import { readdir as readdir7 } from "fs/promises";
 
 // src/hermes/api-server.ts
 async function listHermesModels(options = {}) {
@@ -8970,7 +10128,7 @@ async function createHermesRun(input, options = {}) {
     );
   }
   const payload = await readJsonResponse(response);
-  const runId = readString9(payload, "run_id") ?? readString9(payload, "runId") ?? readString9(payload, "id");
+  const runId = readString10(payload, "run_id") ?? readString10(payload, "runId") ?? readString10(payload, "id");
   if (!runId) {
     throw new LinkHttpError(
       502,
@@ -9083,10 +10241,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 +10252,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 +10279,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 +10300,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 +10311,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 +10334,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 +10386,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 +10463,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 +10509,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 +10527,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 +10564,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 +10676,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 +10687,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 +10707,7 @@ function normalizeHistoryRecord(record) {
   }
   return message;
 }
-function normalizeContent(value) {
+function normalizeContent2(value) {
   if (typeof value === "string") {
     return value;
   }
@@ -9591,12 +10749,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 +10772,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 +10868,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 +10915,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 +10932,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 +10943,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 +10962,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 +10973,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 +11025,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 +11042,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 +11070,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 +11139,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 +11153,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 +11230,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,15 +11266,15 @@ 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");
@@ -10144,7 +11302,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 +11315,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 +11330,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 +11356,7 @@ function stringifyJsonValue(value) {
     return String(value);
   }
 }
-function toRecord9(value) {
+function toRecord10(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 
@@ -10615,7 +11773,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 +11842,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 +11858,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 +11874,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) {
@@ -10967,7 +12125,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 +12161,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 +12204,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 +12231,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 +12284,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 +12307,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") {
@@ -11238,10 +12396,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 +12488,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 +12549,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 +12636,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 +12680,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 +13228,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 +13256,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 +13293,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 +13311,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 +13760,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 +13803,7 @@ function readPositiveInteger2(value) {
   }
   return void 0;
 }
-function readBoolean(value) {
+function readBoolean2(value) {
   if (typeof value === "boolean") {
     return value;
   }
@@ -12724,7 +13906,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
@@ -12816,7 +13998,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)
       })
     };
@@ -12887,7 +14069,7 @@ function registerConversationRoutes(router, options) {
   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 +14085,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 +14094,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 +14124,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 +14188,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({
@@ -13166,26 +14348,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 +14384,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 +14425,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 +14452,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 +14490,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 +14508,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 +14523,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 +14535,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 +14556,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 +14753,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 +14770,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 +14793,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 +14851,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 +15021,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 +15076,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 +15093,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 +15105,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 +15207,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 +15471,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 +15603,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 +15612,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 +15664,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 +15691,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 +15700,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 +15720,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 +15782,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 +15791,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 +15807,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 +15840,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 +15855,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 +15940,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 +15959,7 @@ function readProfilePermissionsInput(body) {
       containerDisk: readPositiveInteger2(
         terminal.container_disk ?? terminal.containerDisk
       ),
-      containerPersistent: readBoolean(
+      containerPersistent: readBoolean2(
         terminal.container_persistent ?? terminal.containerPersistent
       )
     };
@@ -14789,7 +15971,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 +16066,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 +16289,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 +16342,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 +16383,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 +16434,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 +16461,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 +16495,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 +16516,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 +16529,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 +16589,7 @@ async function readCustomProviderSetupSummary(profileName) {
     configurable: true,
     configured: true,
     configurationIssue: null,
-    providerConfigPath: path18.join(
+    providerConfigPath: path19.join(
       resolveHermesProfileDir(profileName),
       "<provider>.json"
     ),
@@ -15485,7 +16667,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 +16676,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 +16718,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 +16726,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 +16742,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 +16750,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 +16890,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 +16943,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 +16966,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 +16975,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 +16993,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 +17018,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 +17044,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 +17053,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 +17073,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 +17095,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 +17107,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 +17133,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 +17166,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 +17185,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 +17217,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 +17236,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 +17269,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 +17277,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 +17296,7 @@ function booleanSetting(key, label, value) {
   return {
     key,
     label,
-    value: readBoolean2(value) ?? false,
+    value: readBoolean3(value) ?? false,
     editable: true,
     kind: "boolean"
   };
@@ -16127,7 +17309,7 @@ function stringSetting(key, label, value, editable = true) {
   return {
     key,
     label,
-    value: readString14(value) ?? "",
+    value: readString15(value) ?? "",
     editable,
     kind: "string"
   };
@@ -16142,21 +17324,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 +17394,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 +17425,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 +17539,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 +17550,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 +17561,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 +17572,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 +17583,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 +17595,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 +17607,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 +17623,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 +17655,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 +17693,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 +17741,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 +17765,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 +17836,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 +17855,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 +17932,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 +17946,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 +17957,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 +17968,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 +17990,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 +18003,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 +18011,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 +18035,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 +18044,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 +18059,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 +18082,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 +18095,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 +18154,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 +18165,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 +18187,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 +18216,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,
@@ -17322,7 +18504,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 +18512,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 +18687,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 +18909,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 +18945,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 +18954,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 +18998,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 +19044,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 +19052,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 +19236,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 +19275,7 @@ function readHostname(platform) {
       return computerName;
     }
   }
-  return normalizeText(os5.hostname());
+  return normalizeText(os6.hostname());
 }
 function readOsLabel(platform) {
   if (platform === "darwin") {
@@ -18101,12 +19283,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 +19335,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 +19368,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 +19413,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 +19906,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 +19953,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 +19987,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 +20029,7 @@ async function startLinkService(options = {}) {
   return {
     async close() {
       scheduler.close();
+      hermesSessionSyncScheduler.close();
       lanIpMonitor.close();
       relay?.close();
       await closeServer(server);
@@ -18917,7 +20142,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 +20271,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 +20597,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 +20619,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 +20672,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 +20681,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 +20736,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 +21024,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 +21065,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 +21097,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 +21171,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 +21183,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 +21261,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 +21292,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 +21303,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 +21325,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 +21550,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 +21590,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()) {
@@ -20463,7 +21688,7 @@ 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) => {
@@ -20497,7 +21722,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 +21747,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 +22151,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,