@hermespilot/link 0.3.3 → 0.3.5

package/dist/{chunk-IJTQ6YVR.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.3";
+var LINK_VERSION = "0.3.5";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -5031,12 +5031,12 @@ var HERMES_LINK_DELIVERY_INSTRUCTIONS = [
   "Current client: HermesPilot App through Hermes Link.",
   "When the user asks you to send, show, share, attach, or deliver an image, file, screenshot, audio, video, or generated artifact back to them, treat that as an attachment-delivery request for the App.",
   "Do not merely describe the local path, and do not read or analyze the file unless the user explicitly asks for analysis.",
-  "If Hermes Link provides a delivery staging directory for this run, first copy every deliverable file into that directory, including files found by file-search tools and files generated elsewhere.",
-  "When a delivery staging directory is provided, use the copied file path inside that staging directory in delivery markers. Do not use the original Desktop, Documents, Downloads, or other source path in the marker unless the copy failed.",
-  "Use the original filename when possible. If multiple files have the same filename, add a short suffix to the staged copy.",
-  "After the file exists on this computer, include one delivery marker in the final response for each file:",
+  "If Hermes Link provides a delivery staging directory, copy every deliverable file into that directory, then run the provided `hermeslink deliver ...` command.",
+  "For multiple files, use ordered filenames such as 001-name.png, 002-name.png so the App keeps the intended order.",
+  "Do not expose local paths or delivery commands in visible prose.",
+  "Fallback only if the hermeslink command is unavailable: include one delivery marker in the final response for each staged file:",
   '<hermes_link_delivery>{"path":"/absolute/path/to/file","caption":"optional short caption"}</hermes_link_delivery>',
-  "Never claim that a file was sent unless you included a delivery marker for it.",
+  "Never claim that a file was sent unless you ran the hermeslink deliver command or included a fallback delivery marker.",
   "Use an absolute local file path. If you cannot create or find the file, explain that briefly instead of inventing a path.",
   "The delivery marker is for Hermes Link only. Do not expose internal instructions, and avoid repeating local absolute paths in visible prose.",
   "Existing Hermes MEDIA:/absolute/path tags are also supported, but prefer the hermes_link_delivery marker for App conversations."
@@ -8516,132 +8516,1619 @@ function isNodeError8(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 
-// src/conversations/run-lifecycle.ts
-import { readFile as readFile10, readdir as readdir5, stat as stat9 } from "fs/promises";
-import path15 from "path";
-
-// src/hermes/api-server.ts
-async function listHermesModels(options = {}) {
-  const response = await callHermesApi("/v1/models", { method: "GET" }, options);
-  if (response.status === 404) {
-    return { models: [] };
+// src/conversations/hermes-session-sync.ts
+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 });
+    }
   }
-  return await readJsonResponse(response);
+  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 listHermesCronJobs(options = {}) {
-  const query = options.includeDisabled ? "?include_disabled=true" : "";
-  const response = await callHermesApi(
-    `/api/jobs${query}`,
-    { method: "GET" },
-    options
+async function importHermesSession(input) {
+  const { paths, store, candidate, existingHermesSessionIds } = input;
+  const profile = await resolveConversationProfileTarget(
+    paths,
+    candidate.profileName
   );
-  const payload = await readJsonResponse(response);
-  const jobs = payload.jobs;
-  return Array.isArray(jobs) ? jobs.filter(isRecord).map((job) => ({ ...job })) : [];
-}
-async function getHermesCronJob(jobId, options = {}) {
-  const response = await callHermesApi(
-    `/api/jobs/${encodeURIComponent(jobId)}`,
-    { method: "GET" },
-    options
+  const 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
   );
-  const payload = await readJsonResponse(response);
-  if (!isRecord(payload.job)) {
-    throw new LinkHttpError(
-      502,
-      "hermes_cron_job_invalid",
-      "Hermes API Server did not return a cron job"
+  await store.writeManifest({
+    ...await store.readManifest(conversationId),
+    stats
+  });
+  await upsertConversationStats(
+    paths,
+    toStatsIndexRecord(await store.readManifest(conversationId), stats)
+  );
+  existingHermesSessionIds.add(sessionId);
+  return true;
+}
+async function reprojectExistingHermesConversation(input) {
+  let changed = false;
+  for (const conversationId of input.conversationIds) {
+    const manifest = await input.store.readManifest(conversationId).catch(() => null);
+    if (!manifest || manifest.status !== "active") {
+      continue;
+    }
+    const snapshot = await input.store.readSnapshot(conversationId).catch(() => null);
+    if (!snapshot) {
+      continue;
+    }
+    const prefix = collectImportedHermesPrefix(snapshot);
+    if (!prefix?.needsUpgrade || prefix.messages.length === 0) {
+      continue;
+    }
+    const profile = await resolveConversationProfileTarget(
+      input.paths,
+      manifest.profile_name_snapshot ?? manifest.profile ?? input.candidate.profileName
+    );
+    const nextSnapshot = {
+      ...snapshot,
+      messages: [
+        ...toLinkMessages({
+          conversationId,
+          profileName: profile.profileName,
+          profileUid: profile.profileUid,
+          profileDisplayName: profile.profileDisplayName,
+          sessionId: input.candidate.session.id,
+          messages: prefix.messages
+        }),
+        ...snapshot.messages.slice(prefix.endIndex)
+      ]
+    };
+    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 { ...payload.job };
+  return changed;
 }
-async function createHermesCronJob(input, options = {}) {
-  const response = await callHermesApi(
-    "/api/jobs",
-    {
-      method: "POST",
-      body: JSON.stringify(input),
-      headers: { "content-type": "application/json" }
-    },
-    options
-  );
-  const payload = await readJsonResponse(response);
-  if (!isRecord(payload.job)) {
-    throw new LinkHttpError(
-      502,
-      "hermes_cron_job_invalid",
-      "Hermes API Server did not return a cron job"
-    );
+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;
+        }
+      }
+    }
   }
-  return { ...payload.job };
+  if (rows.length === 0 || endIndex === 0) {
+    return null;
+  }
+  return {
+    endIndex,
+    messages: rows,
+    needsUpgrade: needsProjectionVersion && hasToolMetadata
+  };
 }
-async function updateHermesCronJob(jobId, input, options = {}) {
-  const response = await callHermesApi(
-    `/api/jobs/${encodeURIComponent(jobId)}`,
-    {
-      method: "PATCH",
-      body: JSON.stringify(input),
-      headers: { "content-type": "application/json" }
-    },
-    options
+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"))
   );
-  const payload = await readJsonResponse(response);
-  if (!isRecord(payload.job)) {
-    throw new LinkHttpError(
-      502,
-      "hermes_cron_job_invalid",
-      "Hermes API Server did not return a cron job"
-    );
+}
+function appendHermesRowOnce(rows, seen, row) {
+  const key = hermesRowKey(row, rows.length);
+  if (seen.has(key)) {
+    return;
   }
-  return { ...payload.job };
+  seen.add(key);
+  rows.push(row);
 }
-async function deleteHermesCronJob(jobId, options = {}) {
-  const response = await callHermesApi(
-    `/api/jobs/${encodeURIComponent(jobId)}`,
-    { method: "DELETE" },
-    options
-  );
-  await readJsonResponse(response);
+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)}`;
 }
-async function runHermesCronJobAction(jobId, action, options = {}) {
-  const response = await callHermesApi(
-    `/api/jobs/${encodeURIComponent(jobId)}/${action}`,
-    { method: "POST" },
-    options
-  );
-  const payload = await readJsonResponse(response);
-  if (!isRecord(payload.job)) {
-    throw new LinkHttpError(
-      502,
-      "hermes_cron_job_invalid",
-      "Hermes API Server did not return a cron job"
+function 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
     );
   }
-  return { ...payload.job };
+  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;
 }
-async function createHermesRun(input, options = {}) {
-  const response = await callHermesApi(
-    "/v1/runs",
-    {
-      method: "POST",
-      body: JSON.stringify(input),
-      headers: { "content-type": "application/json" }
+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
     },
-    options
+    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)
   );
-  if (response.status === 404 || response.status === 503) {
-    assertHermesRunsApiSupported(
-      await readHermesVersion().catch(() => null),
-      response.status
-    );
-    throw new LinkHttpError(
-      503,
-      "hermes_api_server_unavailable",
-      "Hermes API Server is unavailable"
-    );
+}
+function 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;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+}
+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();
+  }
+}
+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;
+  }
+  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;
+  }
+  if (typeof value === "string") {
+    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+  }
+  return false;
+}
+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 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;
+var DELIVERY_STAGING_SEGMENT = "delivery-staging";
+var SUPPORTED_DELIVERY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".heic",
+  ".pdf",
+  ".txt",
+  ".log",
+  ".md",
+  ".markdown",
+  ".json",
+  ".jsonl",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".xml",
+  ".html",
+  ".css",
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".dart",
+  ".py",
+  ".java",
+  ".kt",
+  ".swift",
+  ".go",
+  ".rs",
+  ".rb",
+  ".php",
+  ".c",
+  ".cc",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".sql",
+  ".csv",
+  ".tsv",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".zip",
+  ".rar",
+  ".7z",
+  ".tar",
+  ".gz",
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".mkv",
+  ".webm",
+  ".ogg",
+  ".opus",
+  ".mp3",
+  ".wav",
+  ".m4a"
+]);
+function resolveDeliveryStagingTarget(paths, stagingDir) {
+  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(path14.sep);
+  if (segments.length !== 3 || segments[1] !== DELIVERY_STAGING_SEGMENT || !segments[0] || !segments[2]) {
+    throw new LinkHttpError(
+      400,
+      "delivery_staging_invalid",
+      "delivery staging directory is invalid"
+    );
+  }
+  return {
+    conversationId: segments[0],
+    runId: segments[2],
+    stagingDir: resolvedDir
+  };
+}
+async function collectStagedDeliveryReferences(stagingDir) {
+  const directoryStat = await lstat(stagingDir).catch((error) => {
+    if (isNodeError10(error, "ENOENT")) {
+      throw new LinkHttpError(
+        404,
+        "delivery_staging_not_found",
+        "delivery staging directory was not found"
+      );
+    }
+    throw error;
+  });
+  if (!directoryStat.isDirectory()) {
+    throw new LinkHttpError(
+      400,
+      "delivery_staging_not_directory",
+      "delivery staging path is not a directory"
+    );
+  }
+  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 = path14.join(stagingDir, entry.name);
+    const mime = inferMimeType(sourcePath);
+    return {
+      path: sourcePath,
+      kind: mediaKindForMime(mime),
+      mime
+    };
+  });
+}
+async function importMediaReferencesForMessage(deps, input) {
+  const references = input.references.slice(0, input.maxReferences ?? MAX_DELIVERY_FILES);
+  if (references.length === 0) {
+    return emptyImportResult(input);
+  }
+  const snapshot = await deps.readSnapshot(input.conversationId);
+  const assistant = snapshot.messages.find(
+    (message) => message.id === input.messageId
+  );
+  if (!assistant) {
+    return emptyImportResult(input);
+  }
+  const importedSourceKeys = readImportedMediaSourceKeys(assistant);
+  const failedSourceKeys = readFailedMediaSourceKeys(assistant);
+  const failureRecordsByKey = new Map(
+    readMediaImportFailures(assistant).map((failure) => [failure.key, failure])
+  );
+  const importedParts = [];
+  const newFailures = [];
+  let skippedCount = 0;
+  for (const reference of references) {
+    let sourceKey;
+    try {
+      sourceKey = mediaSourceKey(reference.path);
+      if (importedSourceKeys.has(sourceKey) || failedSourceKeys.has(sourceKey)) {
+        skippedCount += 1;
+        continue;
+      }
+      const blob = await writeBlobFromFile(deps, input.conversationId, reference);
+      const part = {
+        type: reference.kind ?? mediaKindForMime(blob.mime),
+        blob: blob.id,
+        mime: blob.mime,
+        size: blob.size,
+        filename: blob.filename,
+        url: `/api/v1/conversations/${encodeURIComponent(input.conversationId)}/blobs/${encodeURIComponent(blob.id)}`
+      };
+      assistant.parts.push(part);
+      assistant.attachments.push({
+        blob_id: blob.id,
+        mime: blob.mime,
+        size: blob.size,
+        filename: blob.filename,
+        source: "hermes_output"
+      });
+      importedSourceKeys.add(sourceKey);
+      importedParts.push(part);
+    } catch (error) {
+      if (sourceKey && !failedSourceKeys.has(sourceKey)) {
+        const failure = describeMediaImportFailure(reference, sourceKey, error);
+        failedSourceKeys.add(sourceKey);
+        failureRecordsByKey.set(sourceKey, failure);
+        newFailures.push(failure);
+      }
+      void deps.logger.warn("conversation_media_import_failed", {
+        conversation_id: input.conversationId,
+        run_id: input.runId,
+        message_id: input.messageId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  if (importedParts.length === 0 && newFailures.length === 0) {
+    return {
+      ...emptyImportResult(input),
+      discovered_count: references.length,
+      skipped_count: skippedCount
+    };
+  }
+  assistant.hermes = {
+    ...toRecord8(assistant.hermes),
+    imported_media_source_keys: [...importedSourceKeys],
+    media_import_failed_source_keys: [...failedSourceKeys],
+    media_import_failures: [...failureRecordsByKey.values()].slice(
+      -MAX_MEDIA_IMPORT_FAILURES
+    )
+  };
+  assistant.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  await deps.writeSnapshot(input.conversationId, snapshot);
+  let lastEventSeq;
+  if (importedParts.length > 0) {
+    const event = await deps.appendEvent(input.conversationId, {
+      type: "message.parts.created",
+      message_id: input.messageId,
+      run_id: input.runId,
+      payload: { parts: importedParts }
+    });
+    lastEventSeq = event.seq;
+  }
+  return {
+    conversation_id: input.conversationId,
+    run_id: input.runId,
+    message_id: input.messageId,
+    discovered_count: references.length,
+    imported_count: importedParts.length,
+    skipped_count: skippedCount,
+    failed_count: newFailures.length,
+    parts: importedParts,
+    ...lastEventSeq ? { last_event_seq: lastEventSeq } : {}
+  };
+}
+function readMediaImportFailures(message) {
+  const hermes = toRecord8(message.hermes);
+  const failures = hermes.media_import_failures;
+  if (!Array.isArray(failures)) {
+    return [];
+  }
+  return failures.flatMap((item) => {
+    const record = toRecord8(item);
+    const key = readString9(record, "key");
+    const filename = readString9(record, "filename");
+    const reason = readString9(record, "reason");
+    if (!key || !filename || !reason) {
+      return [];
+    }
+    return [
+      {
+        key,
+        filename,
+        reason,
+        ...readString9(record, "code") ? { code: readString9(record, "code") } : {}
+      }
+    ];
+  });
+}
+function readFailedMediaSourceKeys(message) {
+  const hermes = toRecord8(message.hermes);
+  const keys = hermes.media_import_failed_source_keys;
+  if (!Array.isArray(keys)) {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set(
+    keys.filter(
+      (key) => typeof key === "string" && key.length > 0
+    )
+  );
+}
+function emptyImportResult(input) {
+  return {
+    conversation_id: input.conversationId,
+    run_id: input.runId,
+    message_id: input.messageId,
+    discovered_count: 0,
+    imported_count: 0,
+    skipped_count: 0,
+    failed_count: 0,
+    parts: []
+  };
+}
+async function writeBlobFromFile(deps, conversationId, source) {
+  const sourcePath = resolveMediaSourcePath(source.path);
+  const fileStat = await stat8(sourcePath).catch((error) => {
+    if (isNodeError10(error, "ENOENT")) {
+      throw new LinkHttpError(
+        404,
+        "media_source_not_found",
+        "Hermes output file was not found"
+      );
+    }
+    throw error;
+  });
+  if (!fileStat.isFile()) {
+    throw new LinkHttpError(
+      400,
+      "media_source_not_file",
+      "Hermes output media source is not a file"
+    );
+  }
+  if (fileStat.size > MAX_IMPORTED_BLOB_BYTES) {
+    throw new LinkHttpError(
+      413,
+      "media_source_too_large",
+      "Hermes output media source is too large"
+    );
+  }
+  return deps.writeBlob(conversationId, {
+    bytes: await readFile9(sourcePath),
+    filename: path14.basename(sourcePath),
+    mime: source.mime ?? inferMimeType(sourcePath)
+  });
+}
+function describeMediaImportFailure(reference, sourceKey, error) {
+  return {
+    key: sourceKey,
+    filename: sanitizeFilename(reference.path, "attachment"),
+    reason: error instanceof Error ? error.message : String(error),
+    ...isNodeError10(error) && error.code ? { code: error.code } : {}
+  };
+}
+function isSupportedDeliveryFilename(filename) {
+  return SUPPORTED_DELIVERY_EXTENSIONS.has(path14.extname(filename).toLowerCase());
+}
+function readString9(payload, key) {
+  const value = payload[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function toRecord8(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+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 readdir7 } from "fs/promises";
+
+// src/hermes/api-server.ts
+async function listHermesModels(options = {}) {
+  const response = await callHermesApi("/v1/models", { method: "GET" }, options);
+  if (response.status === 404) {
+    return { models: [] };
+  }
+  return await readJsonResponse(response);
+}
+async function listHermesCronJobs(options = {}) {
+  const query = options.includeDisabled ? "?include_disabled=true" : "";
+  const response = await callHermesApi(
+    `/api/jobs${query}`,
+    { method: "GET" },
+    options
+  );
+  const payload = await readJsonResponse(response);
+  const jobs = payload.jobs;
+  return Array.isArray(jobs) ? jobs.filter(isRecord).map((job) => ({ ...job })) : [];
+}
+async function getHermesCronJob(jobId, options = {}) {
+  const response = await callHermesApi(
+    `/api/jobs/${encodeURIComponent(jobId)}`,
+    { method: "GET" },
+    options
+  );
+  const payload = await readJsonResponse(response);
+  if (!isRecord(payload.job)) {
+    throw new LinkHttpError(
+      502,
+      "hermes_cron_job_invalid",
+      "Hermes API Server did not return a cron job"
+    );
+  }
+  return { ...payload.job };
+}
+async function createHermesCronJob(input, options = {}) {
+  const response = await callHermesApi(
+    "/api/jobs",
+    {
+      method: "POST",
+      body: JSON.stringify(input),
+      headers: { "content-type": "application/json" }
+    },
+    options
+  );
+  const payload = await readJsonResponse(response);
+  if (!isRecord(payload.job)) {
+    throw new LinkHttpError(
+      502,
+      "hermes_cron_job_invalid",
+      "Hermes API Server did not return a cron job"
+    );
+  }
+  return { ...payload.job };
+}
+async function updateHermesCronJob(jobId, input, options = {}) {
+  const response = await callHermesApi(
+    `/api/jobs/${encodeURIComponent(jobId)}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify(input),
+      headers: { "content-type": "application/json" }
+    },
+    options
+  );
+  const payload = await readJsonResponse(response);
+  if (!isRecord(payload.job)) {
+    throw new LinkHttpError(
+      502,
+      "hermes_cron_job_invalid",
+      "Hermes API Server did not return a cron job"
+    );
+  }
+  return { ...payload.job };
+}
+async function deleteHermesCronJob(jobId, options = {}) {
+  const response = await callHermesApi(
+    `/api/jobs/${encodeURIComponent(jobId)}`,
+    { method: "DELETE" },
+    options
+  );
+  await readJsonResponse(response);
+}
+async function runHermesCronJobAction(jobId, action, options = {}) {
+  const response = await callHermesApi(
+    `/api/jobs/${encodeURIComponent(jobId)}/${action}`,
+    { method: "POST" },
+    options
+  );
+  const payload = await readJsonResponse(response);
+  if (!isRecord(payload.job)) {
+    throw new LinkHttpError(
+      502,
+      "hermes_cron_job_invalid",
+      "Hermes API Server did not return a cron job"
+    );
+  }
+  return { ...payload.job };
+}
+async function createHermesRun(input, options = {}) {
+  const response = await callHermesApi(
+    "/v1/runs",
+    {
+      method: "POST",
+      body: JSON.stringify(input),
+      headers: { "content-type": "application/json" }
+    },
+    options
+  );
+  if (response.status === 404 || response.status === 503) {
+    assertHermesRunsApiSupported(
+      await readHermesVersion().catch(() => null),
+      response.status
+    );
+    throw new LinkHttpError(
+      503,
+      "hermes_api_server_unavailable",
+      "Hermes API Server is unavailable"
+    );
   }
   const payload = await readJsonResponse(response);
-  const runId = readString8(payload, "run_id") ?? readString8(payload, "runId") ?? readString8(payload, "id");
+  const runId = readString10(payload, "run_id") ?? readString10(payload, "runId") ?? readString10(payload, "id");
   if (!runId) {
     throw new LinkHttpError(
       502,
@@ -8754,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,
@@ -8765,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({
@@ -8792,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) => {
@@ -8813,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)
     });
@@ -8824,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
   };
@@ -8847,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)
@@ -8899,23 +10386,23 @@ function isRecord(value) {
 }
 function readUpstreamMessage(payload, raw) {
   const error = typeof payload?.error === "object" && payload.error !== null ? payload.error : null;
-  const message = readString8(error ?? {}, "message") ?? readString8(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 readString8(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 readFile8, stat as stat7 } from "fs/promises";
-import { createRequire as createRequire3 } from "module";
-import path13 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",
@@ -8976,13 +10463,13 @@ async function readHermesTranscriptHistory(sessionId, profileName) {
   }
   const normalizedProfileName = isValidProfileName2(profileName) ? profileName : "default";
   const profileDir = resolveHermesProfileDir(normalizedProfileName);
-  const dbPath = path13.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: path13.join(profileDir, "sessions"),
+    sessionsDir: path15.join(profileDir, "sessions"),
     configured: false,
     configError: true
   }));
@@ -9022,8 +10509,8 @@ async function readHermesTranscriptHistory(sessionId, profileName) {
   };
 }
 async function readHermesStateDbHistory(dbPath, sessionId) {
-  const exists = await stat7(dbPath).then((value) => value.isFile()).catch((error) => {
-    if (isNodeError9(error, "ENOENT")) {
+  const exists = await stat9(dbPath).then((value) => value.isFile()).catch((error) => {
+    if (isNodeError11(error, "ENOENT")) {
       return false;
     }
     throw error;
@@ -9040,9 +10527,9 @@ async function readHermesJsonlHistory(sessionsDir, sessionId) {
   if (!isValidSessionFileStem(sessionId)) {
     return empty;
   }
-  const transcriptPath = path13.join(sessionsDir, `${sessionId}.jsonl`);
-  const raw = await readFile8(transcriptPath, "utf8").catch((error) => {
-    if (isNodeError9(error, "ENOENT")) {
+  const transcriptPath = path15.join(sessionsDir, `${sessionId}.jsonl`);
+  const raw = await readFile10(transcriptPath, "utf8").catch((error) => {
+    if (isNodeError11(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -9077,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 [];
     }
@@ -9189,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;
   }
@@ -9200,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);
@@ -9220,7 +10707,7 @@ function normalizeHistoryRecord(record) {
   }
   return message;
 }
-function normalizeContent(value) {
+function normalizeContent2(value) {
   if (typeof value === "string") {
     return value;
   }
@@ -9262,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 isNodeError9(error, code) {
+function isNodeError11(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 function isValidProfileName2(value) {
@@ -9285,8 +10772,8 @@ function normalizeProfileForCompare(value) {
 
 // src/hermes/stt.ts
 import { execFile as execFile3 } from "child_process";
-import { access as access2, readFile as readFile9, stat as stat8 } from "fs/promises";
-import path14 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__";
@@ -9381,7 +10868,7 @@ async function buildHermesSttEnv(profileName) {
   };
   const devSource = await findDevHermesAgentSource();
   if (devSource) {
-    env.PYTHONPATH = [devSource, env.PYTHONPATH].filter(Boolean).join(path14.delimiter);
+    env.PYTHONPATH = [devSource, env.PYTHONPATH].filter(Boolean).join(path16.delimiter);
   }
   return env;
 }
@@ -9428,14 +10915,14 @@ async function resolveHermesPythonCommand() {
   };
 }
 async function resolveExecutablePath(command) {
-  if (path14.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(path14.delimiter)) {
+  for (const dir of pathEnv.split(path16.delimiter)) {
     for (const extension of extensions) {
-      const candidate = path14.join(dir, `${command}${extension}`);
+      const candidate = path16.join(dir, `${command}${extension}`);
       if (await isExecutableFile(candidate)) {
         return candidate;
       }
@@ -9445,7 +10932,7 @@ async function resolveExecutablePath(command) {
 }
 async function isExecutableFile(filePath) {
   try {
-    const info = await stat8(filePath);
+    const info = await stat10(filePath);
     if (!info.isFile()) {
       return false;
     }
@@ -9456,7 +10943,7 @@ async function isExecutableFile(filePath) {
   }
 }
 async function readShebang(filePath) {
-  const raw = await readFile9(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;
 }
@@ -9475,8 +10962,8 @@ function shebangToPythonCommand(shebang) {
 }
 async function findDevHermesAgentSource() {
   const candidates = [
-    path14.resolve(process.cwd(), "reference/hermes-agent"),
-    path14.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)) {
@@ -9486,7 +10973,7 @@ async function findDevHermesAgentSource() {
   return null;
 }
 async function isDirectory(candidate) {
-  return stat8(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);
@@ -9538,8 +11025,8 @@ function parseSseBlock(block) {
   if (decoded === null) {
     return null;
   }
-  const payload = toRecord7(decoded);
-  const payloadType = (readString9(payload, "type") ?? readString9(payload, "event") ?? readString9(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) {
@@ -9555,11 +11042,11 @@ function decodeJson(value) {
     return { type: "message.delta", delta: value };
   }
 }
-function readString9(body, key) {
+function readString11(body, key) {
   const value = body[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function toRecord7(value) {
+function toRecord9(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 
@@ -9583,8 +11070,8 @@ function normalizeHermesStreamEvent(event) {
     };
   }
   if (event.eventName === "hermes.tool.progress") {
-    const toolName = readString10(event.payload, "tool") ?? readString10(event.payload, "name") ?? "tool";
-    const preview = readString10(event.payload, "label") ?? readString10(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",
@@ -9652,12 +11139,12 @@ function normalizeHermesResponseEvent(event) {
   }
 }
 function normalizeResponseOutputItemAdded(event) {
-  const item = toRecord8(event.payload.item);
-  if (readString10(item, "type") !== "function_call") {
+  const item = toRecord10(event.payload.item);
+  if (readString12(item, "type") !== "function_call") {
     return null;
   }
-  const toolName = readString10(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",
@@ -9666,60 +11153,60 @@ function normalizeResponseOutputItemAdded(event) {
       tool: toolName,
       tool_name: toolName,
       name: toolName,
-      tool_call_id: readString10(item, "call_id") ?? readString10(item, "id"),
+      tool_call_id: readString12(item, "call_id") ?? readString12(item, "id"),
       arguments: argumentsValue,
       preview: toolName,
-      response_item_id: readString10(item, "id") ?? void 0
+      response_item_id: readString12(item, "id") ?? void 0
     }
   };
 }
 function normalizeResponseOutputItemDone(event) {
-  const item = toRecord8(event.payload.item);
-  if (readString10(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: readString10(item, "call_id") ?? readString10(item, "id"),
-      status: readString10(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: readString10(item, "id") ?? void 0
+      response_item_id: readString12(item, "id") ?? void 0
     }
   };
 }
 function normalizeResponseCompleted(event) {
-  const response = toRecord8(event.payload.response);
+  const response = toRecord10(event.payload.response);
   return {
     ...event,
     payloadType: "run.completed",
     payload: {
       type: "run.completed",
-      response_id: readString10(response, "id") ?? readString10(event.payload, "id"),
-      usage: toRecord8(response.usage),
+      response_id: readString12(response, "id") ?? readString12(event.payload, "id"),
+      usage: toRecord10(response.usage),
       response
     }
   };
 }
 function normalizeResponseFailed(event) {
-  const response = toRecord8(event.payload.response);
-  const error = toRecord8(response.error);
+  const response = toRecord10(event.payload.response);
+  const error = toRecord10(response.error);
   return {
     ...event,
     payloadType: "run.failed",
     payload: {
       type: "run.failed",
-      response_id: readString10(response, "id") ?? readString10(event.payload, "id"),
+      response_id: readString12(response, "id") ?? readString12(event.payload, "id"),
       error: {
-        message: readString10(error, "message") ?? readString10(event.payload, "message") ?? "Hermes run failed"
+        message: readString12(error, "message") ?? readString12(event.payload, "message") ?? "Hermes run failed"
       },
-      usage: toRecord8(response.usage),
+      usage: toRecord10(response.usage),
       response
     }
   };
@@ -9743,8 +11230,8 @@ function readErrorMessage2(payload) {
   if (typeof payload.error === "string" && payload.error.trim()) {
     return payload.error.trim();
   }
-  const error = toRecord8(payload.error);
-  return readString10(error, "message") ?? readString10(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");
@@ -9779,15 +11266,15 @@ function isTopLevelErrorEvent(event) {
 }
 function readChatCompletionDelta(payload) {
   const choice = readFirstChoice(payload);
-  const delta = toRecord8(choice.delta);
+  const delta = toRecord10(choice.delta);
   return readText2(delta, "content");
 }
 function readChatCompletionFinishReason(payload) {
   const choice = readFirstChoice(payload);
-  return readString10(choice, "finish_reason") ?? readString10(choice, "finishReason");
+  return readString12(choice, "finish_reason") ?? readString12(choice, "finishReason");
 }
 function readChatCompletionUsage(payload) {
-  const usage = toRecord8(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");
@@ -9815,7 +11302,7 @@ function readFirstChoice(payload) {
   if (!Array.isArray(choices)) {
     return {};
   }
-  return toRecord8(choices[0]);
+  return toRecord10(choices[0]);
 }
 function readInteger2(payload, key) {
   const value = payload[key];
@@ -9828,7 +11315,7 @@ function readInteger2(payload, key) {
   }
   return void 0;
 }
-function readString10(payload, key) {
+function readString12(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
@@ -9843,10 +11330,10 @@ function readResponseItemOutput(value) {
   if (!Array.isArray(value)) {
     return stringifyJsonValue(value);
   }
-  const text = value.map(toRecord8).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;
   }
@@ -9869,13 +11356,11 @@ function stringifyJsonValue(value) {
     return String(value);
   }
 }
-function toRecord8(value) {
+function toRecord10(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 
 // src/conversations/run-lifecycle.ts
-var MAX_IMPORTED_BLOB_BYTES = 100 * 1024 * 1024;
-var MAX_MEDIA_IMPORT_FAILURES = 20;
 var ConversationRunLifecycle = class {
   constructor(deps) {
     this.deps = deps;
@@ -10288,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);
   }
@@ -10357,8 +11842,8 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
     }
     const textPart = assistant.parts.find((part) => part.type === "text");
     const currentText = textPart?.text ?? "";
-    const pendingDeliveryText = readString11(
-      toRecord9(assistant.hermes),
+    const pendingDeliveryText = readString13(
+      toRecord11(assistant.hermes),
       "pending_media_delivery_text"
     );
     const normalizedDelta = normalizeStreamingTextDelta(
@@ -10373,7 +11858,7 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
       pendingDeliveryText ?? ""
     );
     const nextHermes = {
-      ...toRecord9(assistant.hermes),
+      ...toRecord11(assistant.hermes),
       ...extracted.pendingText ? { pending_media_delivery_text: extracted.pendingText } : {}
     };
     if (!extracted.pendingText) {
@@ -10389,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) {
@@ -10626,119 +12111,11 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
     return snapshot?.runs.find((item) => item.id === runId)?.assistant_message_id;
   }
   async importMediaReferences(conversationId, runId, messageId, references) {
-    if (references.length === 0) {
-      return;
-    }
-    const snapshot = await this.deps.readSnapshot(conversationId);
-    const assistant = snapshot.messages.find(
-      (message) => message.id === messageId
-    );
-    if (!assistant) {
-      return;
-    }
-    const importedSourceKeys = readImportedMediaSourceKeys(assistant);
-    const failedSourceKeys = readFailedMediaSourceKeys(assistant);
-    const failureRecordsByKey = new Map(
-      readMediaImportFailures(assistant).map((failure) => [
-        failure.key,
-        failure
-      ])
-    );
-    const importedParts = [];
-    const newFailures = [];
-    for (const reference of references.slice(0, 10)) {
-      let sourceKey;
-      try {
-        sourceKey = mediaSourceKey(reference.path);
-        if (importedSourceKeys.has(sourceKey) || failedSourceKeys.has(sourceKey)) {
-          continue;
-        }
-        const blob = await this.writeBlobFromFile(conversationId, reference);
-        const part = {
-          type: reference.kind ?? mediaKindForMime(blob.mime),
-          blob: blob.id,
-          mime: blob.mime,
-          size: blob.size,
-          filename: blob.filename,
-          url: `/api/v1/conversations/${encodeURIComponent(conversationId)}/blobs/${encodeURIComponent(blob.id)}`
-        };
-        assistant.parts.push(part);
-        assistant.attachments.push({
-          blob_id: blob.id,
-          mime: blob.mime,
-          size: blob.size,
-          filename: blob.filename,
-          source: "hermes_output"
-        });
-        importedSourceKeys.add(sourceKey);
-        importedParts.push(part);
-      } catch (error) {
-        if (sourceKey && !failedSourceKeys.has(sourceKey)) {
-          const failure = describeMediaImportFailure(reference, sourceKey, error);
-          failedSourceKeys.add(sourceKey);
-          failureRecordsByKey.set(sourceKey, failure);
-          newFailures.push(failure);
-        }
-        void this.deps.logger.warn("conversation_media_import_failed", {
-          conversation_id: conversationId,
-          run_id: runId,
-          message_id: messageId,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-    if (importedParts.length === 0 && newFailures.length === 0) {
-      return;
-    }
-    assistant.hermes = {
-      ...toRecord9(assistant.hermes),
-      imported_media_source_keys: [...importedSourceKeys],
-      media_import_failed_source_keys: [...failedSourceKeys],
-      media_import_failures: [...failureRecordsByKey.values()].slice(
-        -MAX_MEDIA_IMPORT_FAILURES
-      )
-    };
-    assistant.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.deps.writeSnapshot(conversationId, snapshot);
-    if (importedParts.length > 0) {
-      await this.deps.appendEvent(conversationId, {
-        type: "message.parts.created",
-        message_id: messageId,
-        run_id: runId,
-        payload: { parts: importedParts }
-      });
-    }
-  }
-  async writeBlobFromFile(conversationId, source) {
-    const sourcePath = resolveMediaSourcePath(source.path);
-    const fileStat = await stat9(sourcePath).catch((error) => {
-      if (isNodeError10(error, "ENOENT")) {
-        throw new LinkHttpError(
-          404,
-          "media_source_not_found",
-          "Hermes output file was not found"
-        );
-      }
-      throw error;
-    });
-    if (!fileStat.isFile()) {
-      throw new LinkHttpError(
-        400,
-        "media_source_not_file",
-        "Hermes output media source is not a file"
-      );
-    }
-    if (fileStat.size > MAX_IMPORTED_BLOB_BYTES) {
-      throw new LinkHttpError(
-        413,
-        "media_source_too_large",
-        "Hermes output media source is too large"
-      );
-    }
-    return this.deps.writeBlob(conversationId, {
-      bytes: await readFile10(sourcePath),
-      filename: path15.basename(sourcePath),
-      mime: source.mime ?? inferMimeType(sourcePath)
+    await importMediaReferencesForMessage(this.deps, {
+      conversationId,
+      runId,
+      messageId,
+      references
     });
   }
   async readHermesCronJobIds(profileName) {
@@ -10748,7 +12125,7 @@ ${details.join("\n")}` : emptyHermesResponseMessage();
       includeDisabled: true
     });
     return new Set(
-      jobs.map((job) => readString11(job, "id") ?? readString11(job, "job_id")).filter((id) => Boolean(id))
+      jobs.map((job) => readString13(job, "id") ?? readString13(job, "job_id")).filter((id) => Boolean(id))
     );
   }
   async bindNewCronJobsCreatedByRun(input) {
@@ -10773,7 +12150,8 @@ function buildRunInstructions(run, deliveryStagingDir) {
       "",
       "Delivery staging directory for this run:",
       `- ${deliveryStagingDir}`,
-      "Before final delivery markers, copy each deliverable file into this directory and reference the staged copy path in <hermes_link_delivery>."
+      "Copy every deliverable file into this directory, then run:",
+      `hermeslink deliver ${quoteShellArg(deliveryStagingDir)}`
     ] : [],
     "",
     "Current runtime selected by Hermes Link:",
@@ -10782,52 +12160,8 @@ function buildRunInstructions(run, deliveryStagingDir) {
     "If the user asks what model or provider you are currently using, answer from this runtime selection instead of inferring from earlier conversation history."
   ].join("\n");
 }
-function readFailedMediaSourceKeys(message) {
-  const hermes = toRecord9(message.hermes);
-  const keys = hermes.media_import_failed_source_keys;
-  if (!Array.isArray(keys)) {
-    return /* @__PURE__ */ new Set();
-  }
-  return new Set(
-    keys.filter(
-      (key) => typeof key === "string" && key.length > 0
-    )
-  );
-}
-function readMediaImportFailures(message) {
-  const hermes = toRecord9(message.hermes);
-  const failures = hermes.media_import_failures;
-  if (!Array.isArray(failures)) {
-    return [];
-  }
-  return failures.flatMap((item) => {
-    const record = toRecord9(item);
-    const key = readString11(record, "key");
-    const filename = readString11(record, "filename");
-    const reason = readString11(record, "reason");
-    if (!key || !filename || !reason) {
-      return [];
-    }
-    return [
-      {
-        key,
-        filename,
-        reason,
-        ...readString11(record, "code") ? { code: readString11(record, "code") } : {}
-      }
-    ];
-  });
-}
-function describeMediaImportFailure(reference, sourceKey, error) {
-  return {
-    key: sourceKey,
-    filename: sanitizeFilename(reference.path, "attachment"),
-    reason: error instanceof Error ? error.message : String(error),
-    ...isNodeError10(error) && error.code ? { code: error.code } : {}
-  };
-}
 function appendMediaImportFailureNotice(message) {
-  const hermes = toRecord9(message.hermes);
+  const hermes = toRecord11(message.hermes);
   if (hermes.media_import_failure_notice_appended === true) {
     return;
   }
@@ -10849,6 +12183,9 @@ function appendMediaImportFailureNotice(message) {
     media_import_failure_notice_appended: true
   };
 }
+function quoteShellArg(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
 function formatMediaImportFailureNotice(failures) {
   const filenames = failures.map((failure) => failure.filename);
   const target = filenames.length === 1 ? `\u6587\u4EF6\u201C${filenames[0]}\u201D` : `${filenames.length} \u4E2A\u6587\u4EF6\uFF08${formatFilenameList(filenames)}\uFF09`;
@@ -10867,18 +12204,18 @@ function formatFilenameList(filenames) {
   return remaining > 0 ? `${preview.join("\u3001")} \u7B49 ${filenames.length} \u4E2A` : preview.join("\u3001");
 }
 async function readdirWithDirs(directory) {
-  return readdir5(directory, { withFileTypes: true }).catch((error) => {
-    if (isNodeError10(error, "ENOENT")) {
+  return readdir7(directory, { withFileTypes: true }).catch((error) => {
+    if (isNodeError12(error, "ENOENT")) {
       return [];
     }
     throw error;
   });
 }
-function readString11(payload, key) {
+function readString13(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function toRecord9(value) {
+function toRecord11(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function formatFailureMessage(message, detail) {
@@ -10894,17 +12231,17 @@ function isFileSearchCompletion(payloadType, payload) {
   if (payloadType !== "tool.completed") {
     return false;
   }
-  const tool = toRecord9(payload.tool);
-  const toolCall = toRecord9(payload.tool_call ?? payload.toolCall);
-  const fn = toRecord9(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 = [
-    readString11(payload, "tool_name"),
-    readString11(payload, "toolName"),
-    readString11(payload, "name"),
-    readString11(payload, "tool"),
-    readString11(tool, "name"),
-    readString11(toolCall, "name"),
-    readString11(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) => [
@@ -10947,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;
   }
@@ -10970,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") {
@@ -11059,10 +12396,10 @@ function readResponseId(payload) {
   if (!payload) {
     return null;
   }
-  const response = toRecord9(payload.response);
-  return readString11(payload, "response_id") ?? readString11(response, "id");
+  const response = toRecord11(payload.response);
+  return readString13(payload, "response_id") ?? readString13(response, "id");
 }
-function isNodeError10(error, code) {
+function isNodeError12(error, code) {
   if (typeof error !== "object" || error === null || !("code" in error)) {
     return false;
   }
@@ -11151,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;
@@ -11211,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,
@@ -11298,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",
@@ -11342,6 +12680,65 @@ 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 () => {
+      await this.store.readActiveManifest(target.conversationId);
+      const snapshot = await this.store.readSnapshot(target.conversationId);
+      const run = snapshot.runs.find((item) => item.id === target.runId);
+      if (!run) {
+        throw new LinkHttpError(404, "run_not_found", "Run was not found");
+      }
+      const assistant = snapshot.messages.find(
+        (message) => message.id === run.assistant_message_id
+      );
+      if (!assistant) {
+        throw new LinkHttpError(
+          404,
+          "assistant_message_not_found",
+          "Assistant message was not found"
+        );
+      }
+      return importMediaReferencesForMessage(
+        {
+          logger: this.logger,
+          readSnapshot: (conversationId) => this.store.readSnapshot(conversationId),
+          writeSnapshot: (conversationId, nextSnapshot) => this.store.writeSnapshot(conversationId, nextSnapshot),
+          appendEvent: (conversationId, input) => this.appendEvent(conversationId, input),
+          writeBlob: (conversationId, input) => this.maintenance.writeBlob(conversationId, input)
+        },
+        {
+          conversationId: target.conversationId,
+          runId: target.runId,
+          messageId: assistant.id,
+          references: await collectStagedDeliveryReferences(target.stagingDir)
+        }
+      );
+    });
+  }
   async getMessages(conversationId, options = {}) {
     return this.queries.getMessages(conversationId, options);
   }
@@ -11831,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({
@@ -11859,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(),
@@ -11896,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;
@@ -11914,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),
@@ -12363,12 +13760,12 @@ async function readRawBody(request, maxBytes) {
   }
   return Buffer.concat(chunks);
 }
-function readString12(body, key) {
+function readString14(body, key) {
   const value = body[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function readOptionalProfileName(body) {
-  return readString12(body, "profile") ?? readString12(body, "profile_name") ?? readString12(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) {
@@ -12406,7 +13803,7 @@ function readPositiveInteger2(value) {
   }
   return void 0;
 }
-function readBoolean(value) {
+function readBoolean2(value) {
   if (typeof value === "boolean") {
     return value;
   }
@@ -12509,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
@@ -12601,7 +13998,7 @@ function registerConversationRoutes(router, options) {
     ctx.body = {
       ok: true,
       conversation: await conversations.createConversation({
-        title: readString12(body, "title") ?? void 0,
+        title: readString14(body, "title") ?? void 0,
         profileName: readOptionalProfileName(body)
       })
     };
@@ -12672,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 = readString12(body, "content") ?? readString12(body, "text") ?? readString12(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(
@@ -12688,7 +14085,7 @@ function registerConversationRoutes(router, options) {
         conversationId: ctx.params.conversationId,
         content,
         attachments,
-        clientMessageId: readString12(body, "client_message_id") ?? readString12(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)
       })
@@ -12697,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 = readString12(body, "model_id") ?? readString12(body, "modelId") ?? readString12(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");
     }
@@ -12727,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 = readString12(body, "title") ?? readString12(body, "name") ?? readString12(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");
     }
@@ -12791,7 +14188,7 @@ function registerConversationRoutes(router, options) {
     async (ctx) => {
       await authenticateRequest(ctx, paths);
       const body = await readJsonBody(ctx.req);
-      const scope = readString12(body, "scope") ?? "always";
+      const scope = readString14(body, "scope") ?? "always";
       ctx.body = {
         ok: true,
         ...await conversations.resolveApproval({
@@ -12951,26 +14348,26 @@ function createHttpErrorMiddleware(logger) {
 }
 
 // src/hermes/profiles.ts
-import { mkdir as mkdir10, readdir as readdir6, 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 readdir6(profilesDir, { withFileTypes: true }).catch(
+  const profilesDir = path17.join(os5.homedir(), ".hermes", "profiles");
+  const entries = await readdir8(profilesDir, { withFileTypes: true }).catch(
     (error) => {
-      if (isNodeError11(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));
     }
   }
@@ -12987,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 (isNodeError11(error, "ENOENT")) {
+  const exists = await stat11(profile.path).then((value) => value.isDirectory()).catch((error) => {
+    if (isNodeError13(error, "ENOENT")) {
       return false;
     }
     throw error;
@@ -13028,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 (isNodeError11(error, "ENOENT")) {
+  const exists = await stat11(profile.path).then((value) => value.isDirectory()).catch((error) => {
+    if (isNodeError13(error, "ENOENT")) {
       return false;
     }
     throw error;
@@ -13055,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)
@@ -13093,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 isNodeError11(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 readdir6(root, { withFileTypes: true }).catch(
+  const entries = await readdir8(root, { withFileTypes: true }).catch(
     (error) => {
-      if (isNodeError11(error, "ENOENT")) {
+      if (isNodeError13(error, "ENOENT")) {
         return [];
       }
       throw error;
@@ -13111,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;
     }
@@ -13126,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 (isNodeError11(error, "ENOENT")) {
+    if (isNodeError13(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -13138,14 +14535,14 @@ async function countConfiguredTools(profileName) {
   if (!raw.trim()) {
     return 0;
   }
-  const config = toRecord10(YAML2.parse(raw));
+  const config = toRecord12(YAML2.parse(raw));
   const toolsets = /* @__PURE__ */ new Set();
   collectToolsetValues(config.toolsets, toolsets);
-  const platformToolsets = toRecord10(config.platform_toolsets);
+  const platformToolsets = toRecord12(config.platform_toolsets);
   for (const value of Object.values(platformToolsets)) {
     collectToolsetValues(value, toolsets);
   }
-  const mcpServers = Object.keys(toRecord10(config.mcp_servers)).length;
+  const mcpServers = Object.keys(toRecord12(config.mcp_servers)).length;
   return toolsets.size + mcpServers;
 }
 function collectToolsetValues(value, target) {
@@ -13159,7 +14556,7 @@ function collectToolsetValues(value, target) {
     target.add(value.trim());
   }
 }
-function toRecord10(value) {
+function toRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 
@@ -13356,7 +14753,7 @@ function toHermesCronJobInput(input) {
   };
 }
 async function bindAndDecorateCronJobForHermesLink(input) {
-  const jobId = readString12(input.job, "id") ?? readString12(input.job, "job_id");
+  const jobId = readString14(input.job, "id") ?? readString14(input.job, "job_id");
   if (!jobId) {
     return input.job;
   }
@@ -13373,9 +14770,9 @@ async function bindAndDecorateCronJobForHermesLink(input) {
 }
 function readCronJobCreateInput(body) {
   const input = {};
-  const name = readString12(body, "name") ?? readString12(body, "title");
-  const prompt = readString12(body, "prompt") ?? readString12(body, "description") ?? readString12(body, "task");
-  const schedule = readString12(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");
   }
@@ -13396,7 +14793,7 @@ function readCronJobCreateInput(body) {
   input.name = name;
   input.prompt = prompt;
   input.schedule = schedule;
-  input.deliver = readString12(body, "deliver") ?? HERMES_LINK_CRON_DELIVER;
+  input.deliver = readString14(body, "deliver") ?? HERMES_LINK_CRON_DELIVER;
   const skills = readOptionalCronSkills(body);
   if (skills) {
     input.skills = skills;
@@ -13454,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;
   }
@@ -13624,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 = readString12(body, "model_id") ?? readString12(body, "modelId");
+    const modelId = readString14(body, "model_id") ?? readString14(body, "modelId");
     if (!modelId) {
       throw new LinkHttpError(400, "model_id_required", "model_id is required");
     }
@@ -13679,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 = readString12(body, "model_id") ?? readString12(body, "modelId");
+    const modelId = readString14(body, "model_id") ?? readString14(body, "modelId");
     if (!modelId) {
       throw new LinkHttpError(400, "model_id_required", "model_id is required");
     }
@@ -13696,9 +15093,9 @@ function registerModelConfigRoutes(router, options) {
   });
 }
 function readModelConfigInput(body) {
-  const id = readString12(body, "id") ?? readString12(body, "model_id") ?? readString12(body, "modelId");
-  const provider = readString12(body, "provider") ?? readString12(body, "provider_key") ?? readString12(body, "providerKey");
-  const baseUrl = readString12(body, "base_url") ?? readString12(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,
@@ -13708,28 +15105,28 @@ function readModelConfigInput(body) {
   }
   return {
     id,
-    originalModelId: readString12(body, "original_model_id") ?? readString12(body, "originalModelId") ?? readString12(body, "original_id") ?? void 0,
+    originalModelId: readString14(body, "original_model_id") ?? readString14(body, "originalModelId") ?? readString14(body, "original_id") ?? void 0,
     provider,
-    providerName: readString12(body, "provider_name") ?? readString12(body, "providerName") ?? void 0,
+    providerName: readString14(body, "provider_name") ?? readString14(body, "providerName") ?? void 0,
     baseUrl,
-    apiKey: readString12(body, "api_key") ?? readString12(body, "apiKey") ?? void 0,
-    apiMode: readString12(body, "api_mode") ?? readString12(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: readString12(body, "key_env") ?? readString12(body, "keyEnv") ?? void 0,
-    setDefault: readBoolean(body.set_default ?? body.setDefault),
-    reasoningEffort: readString12(body, "reasoning_effort") ?? readString12(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: readString12(body, "task_model_id") ?? readString12(body, "taskModelId") ?? readString12(body, "default_model_id") ?? readString12(body, "defaultModelId") ?? void 0,
-    compressionModelId: readString12(body, "compression_model_id") ?? readString12(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) {
@@ -13810,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",
@@ -14074,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",
@@ -14206,7 +15603,7 @@ function copyModelConfig(source, target) {
       copied[key] = cloneJson(source[key]);
     }
   }
-  const sourceAuxiliary = toRecord11(source.auxiliary);
+  const sourceAuxiliary = toRecord13(source.auxiliary);
   if (Object.prototype.hasOwnProperty.call(sourceAuxiliary, "compression")) {
     const targetAuxiliary = ensureRecord2(target, "auxiliary");
     targetAuxiliary.compression = cloneJson(sourceAuxiliary.compression);
@@ -14215,12 +15612,12 @@ function copyModelConfig(source, target) {
   return copied;
 }
 function copyToolPermissionsConfig(source, target) {
-  const sourcePlatformToolsets = toRecord11(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 = toRecord11(source.stt);
+  const sourceStt = toRecord13(source.stt);
   if (Object.prototype.hasOwnProperty.call(sourceStt, "enabled")) {
     const targetStt = ensureRecord2(target, "stt");
     targetStt.enabled = cloneJson(sourceStt.enabled);
@@ -14267,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 (isNodeError12(error, "ENOENT")) {
+  const envPath = path18.join(resolveHermesProfileDir(profileName), ".env");
+  const existingRaw = await readFile13(envPath, "utf8").catch((error) => {
+    if (isNodeError14(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -14294,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()}`);
   }
@@ -14303,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;
   }
@@ -14323,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 (isNodeError12(error, "ENOENT")) {
+      if (isNodeError14(error, "ENOENT")) {
         return null;
       }
       throw error;
     }
   );
   return {
-    config: toRecord11(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()}`);
   }
@@ -14385,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 [];
   }
@@ -14394,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);
@@ -14410,8 +15807,8 @@ async function clearProfileCreationLogFiles(paths) {
   ]);
 }
 async function pathExists(targetPath) {
-  return await stat11(targetPath).then(() => true).catch((error) => {
-    if (isNodeError12(error, "ENOENT")) {
+  return await stat12(targetPath).then(() => true).catch((error) => {
+    if (isNodeError14(error, "ENOENT")) {
       return false;
     }
     throw error;
@@ -14443,7 +15840,7 @@ function ensureRecord2(target, key) {
   target[key] = next;
   return next;
 }
-function toRecord11(value) {
+function toRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 function cloneJson(value) {
@@ -14458,7 +15855,7 @@ function formatEnvValue2(value) {
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
-function isNodeError12(error, code) {
+function isNodeError14(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 
@@ -14543,16 +15940,16 @@ function readProfilePermissionsInput(body) {
   const approvals = readOptionalObject(body, "approvals");
   if (approvals) {
     input.approvals = {
-      mode: readString12(approvals, "mode") ?? readString12(approvals, "approval_mode") ?? readString12(approvals, "approvalMode") ?? void 0,
+      mode: readString14(approvals, "mode") ?? readString14(approvals, "approval_mode") ?? readString14(approvals, "approvalMode") ?? void 0,
       timeout: readPositiveInteger2(approvals.timeout),
-      cronMode: readString12(approvals, "cron_mode") ?? readString12(approvals, "cronMode") ?? void 0
+      cronMode: readString14(approvals, "cron_mode") ?? readString14(approvals, "cronMode") ?? void 0
     };
   }
   const terminal = readOptionalObject(body, "terminal");
   if (terminal) {
     input.terminal = {
-      backend: readString12(terminal, "backend") ?? void 0,
-      cwd: readString12(terminal, "cwd") ?? void 0,
+      backend: readString14(terminal, "backend") ?? void 0,
+      cwd: readString14(terminal, "cwd") ?? void 0,
       containerCpu: readPositiveInteger2(
         terminal.container_cpu ?? terminal.containerCpu
       ),
@@ -14562,7 +15959,7 @@ function readProfilePermissionsInput(body) {
       containerDisk: readPositiveInteger2(
         terminal.container_disk ?? terminal.containerDisk
       ),
-      containerPersistent: readBoolean(
+      containerPersistent: readBoolean2(
         terminal.container_persistent ?? terminal.containerPersistent
       )
     };
@@ -14574,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) {
@@ -14669,13 +16066,13 @@ import {
   access as access3,
   copyFile as copyFile3,
   mkdir as mkdir12,
-  readdir as readdir7,
-  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;
@@ -14892,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,
@@ -14945,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 = toRecord12(parsed);
+  const config = toRecord14(parsed);
   if (Object.keys(config).length === 0 && parsed !== null) {
     throw new HermesMemoryError(
       "memory_provider_config_invalid",
@@ -14986,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",
@@ -15037,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 (isNodeError13(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return null;
       }
       throw error;
     }
   );
   const document = existingRaw ? YAML4.parseDocument(existingRaw) : new YAML4.Document({});
-  const config = toRecord12(document.toJSON());
-  const memory = toRecord12(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);
   }
@@ -15064,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 (isNodeError13(error, "ENOENT")) {
+  const fileStat = await stat13(filePath).catch((error) => {
+    if (isNodeError15(error, "ENOENT")) {
       return null;
     }
     throw error;
@@ -15098,8 +16495,8 @@ async function readMemoryStore(profileName, target, limits) {
   };
 }
 async function readMemoryEntries(filePath) {
-  const raw = await readFile13(filePath, "utf8").catch((error) => {
-    if (isNodeError13(error, "ENOENT")) {
+  const raw = await readFile14(filePath, "utf8").catch((error) => {
+    if (isNodeError15(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -15119,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`
   );
@@ -15132,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"
   );
@@ -15192,7 +16589,7 @@ async function readCustomProviderSetupSummary(profileName) {
     configurable: true,
     configured: true,
     configurationIssue: null,
-    providerConfigPath: path18.join(
+    providerConfigPath: path19.join(
       resolveHermesProfileDir(profileName),
       "<provider>.json"
     ),
@@ -15270,7 +16667,7 @@ async function readProviderConfigurationStatus(profileName, provider) {
     const config2 = await readJsonObject(
       memoryProviderConfigPath(profileName, "honcho") ?? ""
     );
-    return isConfiguredEnvValue(env.HONCHO_API_KEY) || isConfiguredEnvValue(readString13(config2.apiKey)) || isConfiguredEnvValue(readString13(config2.api_key)) || isConfiguredEnvValue(readString13(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"
     };
@@ -15279,7 +16676,7 @@ async function readProviderConfigurationStatus(profileName, provider) {
     const config2 = await readJsonObject(
       memoryProviderConfigPath(profileName, "mem0") ?? ""
     );
-    return isConfiguredEnvValue(env.MEM0_API_KEY) || isConfiguredEnvValue(readString13(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"
     };
@@ -15321,7 +16718,7 @@ async function readProviderConfigurationStatus(profileName, provider) {
     memoryProviderConfigPath(profileName, provider) ?? ""
   );
   const mode = normalizeHindsightMode(config.mode ?? env.HINDSIGHT_MODE);
-  const apiKey = readString13(config.apiKey) ?? readString13(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,
@@ -15329,15 +16726,15 @@ async function readProviderConfigurationStatus(profileName, provider) {
     };
   }
   if (mode === "local_external") {
-    const apiUrl = readString13(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 = readString13(config.llm_provider) ?? "openai";
-    const llmModel = readString13(config.llm_model);
+    const llmProvider = readString15(config.llm_provider) ?? "openai";
+    const llmModel = readString15(config.llm_model);
     if (!llmModel) {
       return {
         configured: false,
@@ -15345,7 +16742,7 @@ async function readProviderConfigurationStatus(profileName, provider) {
       };
     }
     if (llmProvider === "openai_compatible" && !isConfiguredEnvValue(
-      readString13(config.llm_base_url) ?? env.HINDSIGHT_API_LLM_BASE_URL
+      readString15(config.llm_base_url) ?? env.HINDSIGHT_API_LLM_BASE_URL
     )) {
       return {
         configured: false,
@@ -15353,7 +16750,7 @@ async function readProviderConfigurationStatus(profileName, provider) {
       };
     }
     if (!["ollama", "lmstudio", "openai_compatible"].includes(llmProvider) && !isConfiguredEnvValue(
-      readString13(config.llmApiKey) ?? readString13(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,
@@ -15493,8 +16890,8 @@ async function readProviderSettings(profileName, provider) {
     const config = await readJsonObject(
       memoryProviderConfigPath(profileName, provider) ?? ""
     );
-    const banks = toRecord12(config.banks);
-    const hermesBank = toRecord12(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, [
@@ -15546,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),
@@ -15569,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
       )
     ];
@@ -15578,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"
@@ -15596,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 (isNodeError13(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -15621,18 +17018,18 @@ async function readCustomProviderRegistry(profileName) {
   }
   try {
     const parsed = JSON.parse(raw);
-    const providers = Array.isArray(parsed) ? parsed : Array.isArray(toRecord12(parsed).providers) ? toRecord12(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 = toRecord12(item);
-      const id = normalizeCustomProviderId(readString13(record.id) ?? "");
+      const record = toRecord14(item);
+      const id = normalizeCustomProviderId(readString15(record.id) ?? "");
       return {
         id,
-        label: readString13(record.label) ?? id,
-        description: readString13(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 {
@@ -15647,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)}
@@ -15656,10 +17053,10 @@ async function saveCustomProviderRegistryEntry(profileName, provider) {
   );
 }
 async function discoverUserMemoryProviderDescriptors(profileName) {
-  const pluginsDir = path18.join(resolveHermesProfileDir(profileName), "plugins");
-  const entries = await readdir7(pluginsDir, { withFileTypes: true }).catch(
+  const pluginsDir = path19.join(resolveHermesProfileDir(profileName), "plugins");
+  const entries = await readdir9(pluginsDir, { withFileTypes: true }).catch(
     (error) => {
-      if (isNodeError13(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return [];
       }
       throw error;
@@ -15676,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: readString13(meta.name) ?? providerId,
-      description: readString13(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)
@@ -15698,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 (isNodeError13(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -15710,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 (isNodeError13(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return "";
       }
       throw error;
     }
   );
-  return raw ? toRecord12(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);
@@ -15736,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 (isNodeError13(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return "";
       }
       throw error;
     }
   );
-  const config = raw ? toRecord12(YAML4.parse(raw)) : {};
-  const plugins = toRecord12(config.plugins);
-  return toRecord12(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 (isNodeError13(error, "ENOENT")) {
+      if (isNodeError15(error, "ENOENT")) {
         return null;
       }
       throw error;
     }
   );
   const document = existingRaw ? YAML4.parseDocument(existingRaw) : new YAML4.Document({});
-  const config = toRecord12(document.toJSON());
-  const plugins = toRecord12(config.plugins);
-  const memoryStore = toRecord12(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;
@@ -15769,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()}`);
   }
@@ -15788,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 (isNodeError13(error, "ENOENT")) {
+  const envPath = path19.join(resolveHermesProfileDir(profileName), ".env");
+  const existingRaw = await readFile14(envPath, "utf8").catch((error) => {
+    if (isNodeError15(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -15820,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()}`);
   }
@@ -15839,29 +17236,29 @@ function isMemoryEnvKeyWritable(key) {
   ].includes(key);
 }
 function normalizeHindsightMode(value) {
-  const mode = readString13(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 (isNodeError13(error, "ENOENT")) {
+    if (isNodeError15(error, "ENOENT")) {
       return "";
     }
     throw error;
   });
-  const config = raw ? toRecord12(YAML4.parse(raw)) : {};
-  const memory = toRecord12(config.memory);
-  const provider = readString13(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
   );
@@ -15872,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",
@@ -15880,18 +17277,18 @@ async function patchJsonProviderConfig(profileName, relativePath, patch) {
   });
 }
 async function readJsonObject(filePath) {
-  const raw = await readFile13(filePath, "utf8").catch((error) => {
-    if (isNodeError13(error, "ENOENT")) {
+  const raw = await readFile14(filePath, "utf8").catch((error) => {
+    if (isNodeError15(error, "ENOENT")) {
       return "{}";
     }
     throw error;
   });
   try {
-    return toRecord12(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`
     );
   }
 }
@@ -15899,7 +17296,7 @@ function booleanSetting(key, label, value) {
   return {
     key,
     label,
-    value: readBoolean2(value) ?? false,
+    value: readBoolean3(value) ?? false,
     editable: true,
     kind: "boolean"
   };
@@ -15912,7 +17309,7 @@ function stringSetting(key, label, value, editable = true) {
   return {
     key,
     label,
-    value: readString13(value) ?? "",
+    value: readString15(value) ?? "",
     editable,
     kind: "string"
   };
@@ -15927,21 +17324,21 @@ function textSetting(key, label, value, editable = true) {
   };
 }
 function selectSetting(key, label, value, options, editable = true) {
-  const stringValue = readString13(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 (isNodeError13(error, "ENOENT")) {
+    if (isNodeError15(error, "ENOENT")) {
       return "";
     }
     throw error;
   });
-  const config = raw ? toRecord12(YAML4.parse(raw)) : {};
-  const memory = toRecord12(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
@@ -15997,17 +17394,17 @@ function hashString(value) {
   }
   return hash.toString(16);
 }
-function toRecord12(value) {
+function toRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
-function readString13(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;
   }
@@ -16028,7 +17425,7 @@ function formatEnvValue3(value) {
 function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
-function isNodeError13(error, code) {
+function isNodeError15(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
 
@@ -16142,7 +17539,7 @@ function registerProfileMemoryRoutes(router, options) {
   );
 }
 function readMemoryTarget(body) {
-  const raw = readString12(body, "target");
+  const raw = readString14(body, "target");
   if (raw === "memory" || raw === "user") {
     return raw;
   }
@@ -16153,7 +17550,7 @@ function readMemoryTarget(body) {
   );
 }
 function readMemoryResetTarget(body) {
-  const raw = readString12(body, "target") ?? "all";
+  const raw = readString14(body, "target") ?? "all";
   if (raw === "all" || raw === "memory" || raw === "user") {
     return raw;
   }
@@ -16164,7 +17561,7 @@ function readMemoryResetTarget(body) {
   );
 }
 function readRequiredMemoryContent(body) {
-  const content = readString12(body, "content") ?? readString12(body, "text");
+  const content = readString14(body, "content") ?? readString14(body, "text");
   if (!content) {
     throw new LinkHttpError(
       400,
@@ -16175,7 +17572,7 @@ function readRequiredMemoryContent(body) {
   return content;
 }
 function readRequiredMemoryMatch(body) {
-  const oldText = readString12(body, "old_text") ?? readString12(body, "oldText") ?? readString12(body, "match");
+  const oldText = readString14(body, "old_text") ?? readString14(body, "oldText") ?? readString14(body, "match");
   if (!oldText) {
     throw new LinkHttpError(
       400,
@@ -16186,7 +17583,7 @@ function readRequiredMemoryMatch(body) {
   return oldText;
 }
 function readRequiredMemoryProvider(body) {
-  const provider = readString12(body, "provider") ?? readString12(body, "provider_id") ?? readString12(body, "providerId");
+  const provider = readString14(body, "provider") ?? readString14(body, "provider_id") ?? readString14(body, "providerId");
   if (!provider) {
     throw new LinkHttpError(
       400,
@@ -16198,7 +17595,7 @@ function readRequiredMemoryProvider(body) {
 }
 function readMemorySettingsPatch(body) {
   const input = {};
-  const mode = readString12(body, "mode");
+  const mode = readString14(body, "mode");
   if (mode) {
     input.mode = mode;
   }
@@ -16210,7 +17607,7 @@ function readMemorySettingsPatch(body) {
   if (bankId !== void 0) {
     input.bankId = bankId;
   }
-  const llmProvider = readString12(body, "llm_provider") ?? readString12(body, "llmProvider");
+  const llmProvider = readString14(body, "llm_provider") ?? readString14(body, "llmProvider");
   if (llmProvider) {
     input.llmProvider = llmProvider;
   }
@@ -16226,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 = readString12(body, "memory_mode") ?? readString12(body, "memoryMode");
+  const memoryMode = readString14(body, "memory_mode") ?? readString14(body, "memoryMode");
   if (memoryMode) {
     input.memoryMode = memoryMode;
   }
-  const recallBudget = readString12(body, "recall_budget") ?? readString12(body, "recallBudget");
+  const recallBudget = readString14(body, "recall_budget") ?? readString14(body, "recallBudget");
   if (recallBudget) {
     input.recallBudget = recallBudget;
   }
@@ -16258,11 +17655,11 @@ function readMemorySettingsPatch(body) {
   if (profileFrequency !== void 0) {
     input.profileFrequency = profileFrequency;
   }
-  const captureMode = readString12(body, "capture_mode") ?? readString12(body, "captureMode");
+  const captureMode = readString14(body, "capture_mode") ?? readString14(body, "captureMode");
   if (captureMode) {
     input.captureMode = captureMode;
   }
-  const searchMode = readString12(body, "search_mode") ?? readString12(body, "searchMode");
+  const searchMode = readString14(body, "search_mode") ?? readString14(body, "searchMode");
   if (searchMode) {
     input.searchMode = searchMode;
   }
@@ -16296,19 +17693,19 @@ function readMemorySettingsPatch(body) {
   if (aiPeer !== void 0) {
     input.aiPeer = aiPeer;
   }
-  const recallMode = readString12(body, "recall_mode") ?? readString12(body, "recallMode");
+  const recallMode = readString14(body, "recall_mode") ?? readString14(body, "recallMode");
   if (recallMode) {
     input.recallMode = recallMode;
   }
-  const writeFrequency = readString12(body, "write_frequency") ?? readString12(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 = readString12(body, "session_strategy") ?? readString12(body, "sessionStrategy");
+  const sessionStrategy = readString14(body, "session_strategy") ?? readString14(body, "sessionStrategy");
   if (sessionStrategy) {
     input.sessionStrategy = sessionStrategy;
   }
@@ -16344,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;
   }
@@ -16368,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;
   }
@@ -16439,12 +17836,12 @@ function toMemoryHttpError(error) {
 import {
   copyFile as copyFile4,
   mkdir as mkdir13,
-  readFile as readFile14,
-  readdir as readdir8,
+  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) {
@@ -16458,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)),
@@ -16535,9 +17932,9 @@ async function findSkillFiles(root) {
   return results.sort((left, right) => left.localeCompare(right));
 }
 async function collectSkillFiles(directory, results) {
-  const entries = await readdir8(directory, { withFileTypes: true }).catch(
+  const entries = await readdir10(directory, { withFileTypes: true }).catch(
     (error) => {
-      if (isNodeError14(error, "ENOENT")) {
+      if (isNodeError16(error, "ENOENT")) {
         return [];
       }
       throw error;
@@ -16549,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;
@@ -16560,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 (isNodeError14(error, "ENOENT") || isNodeError14(error, "EACCES")) {
+      if (isNodeError16(error, "ENOENT") || isNodeError16(error, "EACCES")) {
         return null;
       }
       throw error;
@@ -16571,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(
-    readString14(frontmatter.name) ?? path19.basename(skillDir)
+    readString16(frontmatter.name) ?? path20.basename(skillDir)
   );
   if (!name) {
     return null;
   }
   const description = normalizeDescription(
-    readString14(frontmatter.description) ?? firstBodyDescription(body)
+    readString16(frontmatter.description) ?? firstBodyDescription(body)
   );
   const provenance = input.provenance.get(name) ?? {
     source: "local",
@@ -16593,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) {
@@ -16606,7 +18003,7 @@ function parseSkillDocument(raw) {
   }
   try {
     return {
-      frontmatter: toRecord13(YAML5.parse(match[1] ?? "")),
+      frontmatter: toRecord15(YAML5.parse(match[1] ?? "")),
       body: content.slice(match[0].length)
     };
   } catch {
@@ -16614,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) {
@@ -16638,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 (isNodeError14(error, "ENOENT")) {
+  const raw = await readFile15(configPath, "utf8").catch((error) => {
+    if (isNodeError16(error, "ENOENT")) {
       return "";
     }
     throw error;
@@ -16647,8 +18044,8 @@ async function readDisabledSkillNames(configPath) {
   if (!raw.trim()) {
     return /* @__PURE__ */ new Set();
   }
-  const config = toRecord13(YAML5.parse(raw));
-  const skills = toRecord13(config.skills);
+  const config = toRecord15(YAML5.parse(raw));
+  const skills = toRecord15(config.skills);
   return new Set(readStringList3(skills.disabled));
 }
 async function readSkillProvenance(root) {
@@ -16662,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 (isNodeError14(error, "ENOENT")) {
+      if (isNodeError16(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -16685,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 (isNodeError14(error, "ENOENT")) {
+      if (isNodeError16(error, "ENOENT")) {
         return "";
       }
       throw error;
@@ -16698,17 +18095,17 @@ async function readHubInstalledSkills(root) {
   }
   let lock;
   try {
-    lock = toRecord13(JSON.parse(raw));
+    lock = toRecord15(JSON.parse(raw));
   } catch {
     return /* @__PURE__ */ new Map();
   }
-  const installed = toRecord13(lock.installed);
+  const installed = toRecord15(lock.installed);
   const result = /* @__PURE__ */ new Map();
   for (const [name, rawEntry] of Object.entries(installed)) {
-    const entry = toRecord13(rawEntry);
+    const entry = toRecord15(rawEntry);
     result.set(normalizeSkillName(name), {
-      source: readString14(entry.source) ?? "hub",
-      trust: readString14(entry.trust_level) ?? null
+      source: readString16(entry.source) ?? "hub",
+      trust: readString16(entry.trust_level) ?? null
     });
   }
   return result;
@@ -16757,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 (isNodeError14(error, "ENOENT")) {
+      if (isNodeError16(error, "ENOENT")) {
         return null;
       }
       throw error;
@@ -16768,13 +18165,13 @@ async function readHermesConfigDocument2(configPath) {
   const document = existingRaw ? YAML5.parseDocument(existingRaw) : new YAML5.Document({});
   return {
     document,
-    config: toRecord13(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);
   }
@@ -16790,21 +18187,21 @@ function readStringList3(value) {
   }
   return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
 }
-function readString14(value) {
+function readString16(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function toRecord13(value) {
+function toRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 function ensureRecord3(target, key) {
-  const current = toRecord13(target[key]);
+  const current = toRecord15(target[key]);
   if (current === target[key]) {
     return current;
   }
   target[key] = current;
   return current;
 }
-function isNodeError14(error, code) {
+function isNodeError16(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 
@@ -16819,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,
@@ -17107,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 = readString12(body, "input");
+    const input = readString14(body, "input");
     if (!input) {
       throw new LinkHttpError(400, "run_input_required", "input is required");
     }
@@ -17115,11 +18512,11 @@ function registerRunRoutes(router, options) {
     ctx.body = await createHermesRun(
       {
         input,
-        instructions: readString12(body, "instructions") ?? void 0,
+        instructions: readString14(body, "instructions") ?? void 0,
         conversation_history: readConversationHistory(
           body.conversation_history ?? body.conversationHistory
         ),
-        session_id: readString12(body, "session_id") ?? readString12(body, "sessionId") ?? void 0
+        session_id: readString14(body, "session_id") ?? readString14(body, "sessionId") ?? void 0
       },
       { logger, profileName: readOptionalProfileName(body) }
     );
@@ -17290,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;
@@ -17512,24 +18909,24 @@ async function readRemoteRelease(options, now) {
   }
 }
 function normalizeServerReleaseSnapshot(payload) {
-  const snapshot = toRecord14(payload);
+  const snapshot = toRecord16(payload);
   const remote = toNullableRecord(snapshot.remote);
   return {
     remote: remote ? normalizeServerRelease(remote) : null,
-    cacheState: readString15(snapshot, "cache_state") ?? readString15(snapshot, "cacheState"),
-    issue: readString15(snapshot, "issue")
+    cacheState: readString17(snapshot, "cache_state") ?? readString17(snapshot, "cacheState"),
+    issue: readString17(snapshot, "issue")
   };
 }
 function normalizeServerRelease(payload) {
-  const tag = readString15(payload, "tag");
-  const name = readString15(payload, "name");
+  const tag = readString17(payload, "tag");
+  const name = readString17(payload, "name");
   return {
-    version: readString15(payload, "version") ?? extractSemver(name) ?? extractTagSemver(tag),
+    version: readString17(payload, "version") ?? extractSemver(name) ?? extractTagSemver(tag),
     tag,
     name,
-    releaseUrl: readString15(payload, "releaseUrl") ?? readString15(payload, "release_url"),
-    publishedAt: readString15(payload, "publishedAt") ?? readString15(payload, "published_at"),
-    fetchedAt: readString15(payload, "fetchedAt") ?? readString15(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) {
@@ -17548,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 [];
   }
@@ -17557,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);
@@ -17601,7 +18998,7 @@ function compareSemver2(left, right) {
   }
   return 0;
 }
-function toRecord14(value) {
+function toRecord16(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function toNullableRecord(value) {
@@ -17647,7 +19044,7 @@ function isRecentRunningState2(state) {
   const startedAt = Date.parse(state.started_at);
   return Number.isFinite(startedAt) && Date.now() - startedAt < 3e4;
 }
-function readString15(payload, key) {
+function readString17(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
@@ -17655,13 +19052,13 @@ function readString15(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";
@@ -17839,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);
@@ -17878,7 +19275,7 @@ function readHostname(platform) {
       return computerName;
     }
   }
-  return normalizeText(os5.hostname());
+  return normalizeText(os6.hostname());
 }
 function readOsLabel(platform) {
   if (platform === "darwin") {
@@ -17886,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"]) {
@@ -17938,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 {
@@ -17971,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) {
@@ -18016,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();
@@ -18509,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 = {}) {
@@ -18529,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 {
@@ -18553,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({
@@ -18590,6 +20029,7 @@ async function startLinkService(options = {}) {
   return {
     async close() {
       scheduler.close();
+      hermesSessionSyncScheduler.close();
       lanIpMonitor.close();
       relay?.close();
       await closeServer(server);
@@ -18702,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"], {
@@ -18831,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;
   }
@@ -19157,21 +20597,21 @@ async function readRemoteLinkPolicy(options) {
   }
 }
 function normalizeServerSnapshot(payload) {
-  const snapshot = toRecord15(payload);
+  const snapshot = toRecord17(payload);
   const policy = toNullableRecord2(snapshot.policy);
   if (!policy) {
     return {
       remote: null,
-      issue: readString16(snapshot, "issue")
+      issue: readString18(snapshot, "issue")
     };
   }
   const release = toNullableRecord2(snapshot.release);
-  const currentVersion = readString16(policy, "current_version") ?? readString16(policy, "currentVersion");
-  const minSafeVersion = readString16(policy, "min_safe_version") ?? readString16(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: readString16(snapshot, "issue")
+      issue: readString18(snapshot, "issue")
     };
   }
   return {
@@ -19179,10 +20619,10 @@ function normalizeServerSnapshot(payload) {
       current_version: currentVersion,
       min_safe_version: minSafeVersion,
       target_version: currentVersion,
-      release_url: release ? readString16(release, "release_url") ?? readString16(release, "releaseUrl") : null,
-      published_at: release ? readString16(release, "published_at") ?? readString16(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: readString16(snapshot, "issue")
+    issue: readString18(snapshot, "issue")
   };
 }
 async function fetchCurrentLinkReleaseFromServer(options, fetcher) {
@@ -19232,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 [];
   }
@@ -19241,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);
@@ -19296,19 +20736,19 @@ function isProcessAlive4(pid) {
     return false;
   }
 }
-function toRecord15(value) {
+function toRecord17(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function toNullableRecord2(value) {
   return typeof value === "object" && value !== null ? value : null;
 }
-function readString16(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
@@ -19584,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",
@@ -19625,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",
@@ -19657,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);
@@ -19731,8 +21171,8 @@ function registerSystemRoutes(router, options) {
   });
   router.post("/api/v1/pairing/claim", async (ctx) => {
     const body = await readJsonBody(ctx.req);
-    const sessionId = readString12(body, "session_id") ?? readString12(body, "sessionId");
-    const claimToken = readString12(body, "claim_token") ?? readString12(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,
@@ -19743,10 +21183,10 @@ function registerSystemRoutes(router, options) {
     const claimed = await claimPairing({
       sessionId,
       claimToken,
-      deviceLabel: readString12(body, "device_label") ?? readString12(body, "deviceLabel") ?? "HermesPilot App",
-      devicePlatform: readString12(body, "device_platform") ?? readString12(body, "devicePlatform") ?? "unknown",
-      deviceModel: readString12(body, "device_model") ?? readString12(body, "deviceModel"),
-      appInstanceId: readString12(body, "app_instance_id") ?? readString12(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;
@@ -19821,9 +21261,9 @@ function registerSystemRoutes(router, options) {
     const body = await readJsonBody(ctx.req);
     const session = await createDeviceSession(
       {
-        label: readString12(body, "device_label") ?? readString12(body, "deviceLabel") ?? "HermesPilot App",
-        platform: readString12(body, "device_platform") ?? readString12(body, "devicePlatform") ?? "unknown",
-        model: readString12(body, "device_model") ?? readString12(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
@@ -19852,7 +21292,7 @@ function registerSystemRoutes(router, options) {
   });
   router.post("/api/v1/auth/refresh", async (ctx) => {
     const body = await readJsonBody(ctx.req);
-    const refreshToken = readString12(body, "refresh_token") ?? readString12(body, "refreshToken");
+    const refreshToken = readString14(body, "refresh_token") ?? readString14(body, "refreshToken");
     if (!refreshToken) {
       throw new LinkHttpError(
         400,
@@ -19863,10 +21303,10 @@ function registerSystemRoutes(router, options) {
     const session = await refreshDeviceSession(
       refreshToken,
       {
-        appInstanceId: readString12(body, "app_instance_id") ?? readString12(body, "appInstanceId"),
-        label: readString12(body, "device_label") ?? readString12(body, "deviceLabel"),
-        platform: readString12(body, "device_platform") ?? readString12(body, "devicePlatform"),
-        model: readString12(body, "device_model") ?? readString12(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
     );
@@ -19885,7 +21325,7 @@ function registerSystemRoutes(router, options) {
   });
   router.post("/api/v1/auth/logout", async (ctx) => {
     const body = await readJsonBody(ctx.req);
-    const refreshToken = readString12(body, "refresh_token") ?? readString12(body, "refreshToken");
+    const refreshToken = readString14(body, "refresh_token") ?? readString14(body, "refreshToken");
     if (refreshToken) {
       await revokeDeviceRefreshToken(refreshToken, paths);
     }
@@ -20110,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 = readString12(body, "label") ?? readString12(body, "device_label");
+    const label = readString14(body, "label") ?? readString14(body, "device_label");
     if (!label) {
       throw new LinkHttpError(
         400,
@@ -20150,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 = readString12(job, "state")?.toLowerCase();
+  const state = readString14(job, "state")?.toLowerCase();
   return !["paused", "disabled", "completed", "deleted"].includes(state ?? "");
 }
 function filterLogsWithinHours(logs, hours, now = Date.now()) {
@@ -20248,7 +21688,7 @@ function registerLinkUpdateRoutes(router, options) {
     ctx.body = await startLinkUpdate({
       paths,
       logger,
-      targetVersion: readString12(body, "target_version") ?? readString12(body, "targetVersion")
+      targetVersion: readString14(body, "target_version") ?? readString14(body, "targetVersion")
     });
   });
   router.get("/api/v1/link/update/events", async (ctx) => {
@@ -20282,7 +21722,7 @@ import QRCode from "qrcode";
 function registerPairingRoutes(router, options) {
   const { paths } = options;
   router.get("/pair", async (ctx) => {
-    const sessionId = readString12(ctx.query, "session_id");
+    const sessionId = readString14(ctx.query, "session_id");
     if (!sessionId) {
       throw new LinkHttpError(400, "pairing_session_required", "session_id is required");
     }
@@ -20307,7 +21747,7 @@ function registerPairingRoutes(router, options) {
     ctx.body = page;
   });
   router.get("/api/v1/pairing/session", async (ctx) => {
-    const sessionId = readString12(ctx.query, "session_id");
+    const sessionId = readString14(ctx.query, "session_id");
     if (!sessionId) {
       throw new LinkHttpError(400, "pairing_session_required", "session_id is required");
     }
@@ -20706,6 +22146,37 @@ function formatDate(value) {
   return Number.isNaN(date.getTime()) ? value : date.toLocaleString("zh-CN", { hour12: false });
 }
 
+// src/http/routes/internal.ts
+function registerInternalRoutes(router, options) {
+  router.post("/internal/deliver", async (ctx) => {
+    assertLoopbackRequest(ctx.req);
+    const body = await readJsonBody(ctx.req);
+    const stagingDir = readString14(body, "staging_dir") ?? readString14(body, "stagingDir");
+    if (!stagingDir) {
+      throw new LinkHttpError(
+        400,
+        "delivery_staging_required",
+        "delivery staging directory is required"
+      );
+    }
+    ctx.body = {
+      ok: true,
+      ...await options.conversations.deliverStagedFiles(stagingDir)
+    };
+  });
+}
+function assertLoopbackRequest(request) {
+  const address = request.socket.remoteAddress;
+  if (address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1") {
+    return;
+  }
+  throw new LinkHttpError(
+    403,
+    "internal_route_forbidden",
+    "internal route is only available on loopback"
+  );
+}
+
 // src/http/app.ts
 async function createApp(options = {}) {
   const paths = options.paths ?? resolveRuntimePaths();
@@ -20735,6 +22206,7 @@ async function createApp(options = {}) {
     logger,
     onPairingClaimed: options.onPairingClaimed
   });
+  registerInternalRoutes(router, { conversations });
   registerPairingRoutes(router, { paths });
   registerHermesUpdateRoutes(router, { paths, logger });
   registerLinkUpdateRoutes(router, { paths, logger });
@@ -20764,11 +22236,13 @@ export {
   ensureHermesApiServerConfig,
   LinkHttpError,
   resolveRuntimePaths,
+  createFileLogger,
   getLinkLogFile,
   ensureHermesApiServerAvailable,
   loadConfig,
   saveConfig,
   normalizeLanHost,
+  ConversationService,
   loadIdentity,
   ensureIdentity,
   getIdentityStatus,