@hermespilot/link 0.8.1-beta.1 → 0.8.1-beta.3

package/dist/{chunk-WYVLVDXH.js → chunk-IJSMGOPK.js}

@@ -4,8 +4,8 @@ import Router from "@koa/router";
 
 // src/conversations/conversation-service.ts
 import { EventEmitter } from "events";
-import { createHash as createHash8, randomUUID as randomUUID12 } from "crypto";
-import path26 from "path";
+import { createHash as createHash9, randomUUID as randomUUID12 } from "crypto";
+import path27 from "path";
 
 // src/database/link-database.ts
 import { mkdir } from "fs/promises";
@@ -207,6 +207,15 @@ var MIGRATIONS = [
       ALTER TABLE live_activities ADD COLUMN last_detail_text TEXT;
       ALTER TABLE live_activities ADD COLUMN last_visible_updated_at TEXT;
     `
+  },
+  {
+    version: 6,
+    name: "live_activity_todo_progress",
+    sql: `
+      ALTER TABLE live_activities ADD COLUMN last_todo_done_count INTEGER;
+      ALTER TABLE live_activities ADD COLUMN last_todo_total_count INTEGER;
+      ALTER TABLE live_activities ADD COLUMN last_todo_progress_text TEXT;
+    `
   }
 ];
 async function migrateLinkDatabase(paths) {
@@ -335,13 +344,16 @@ async function upsertLiveActivity(paths, input) {
           last_status_label,
           last_progress_text,
           last_detail_text,
+          last_todo_done_count,
+          last_todo_total_count,
+          last_todo_progress_text,
           last_visible_updated_at,
           push_count,
           started_at,
           ended_at,
           created_at,
           updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, NULL, NULL, ?, ?, ?, ?, 0, ?, NULL, ?, ?)
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, NULL, NULL, ?, ?, ?, ?, ?, ?, ?, 0, ?, NULL, ?, ?)
         ON CONFLICT(activity_id) DO UPDATE SET
           activity_token = excluded.activity_token,
           apns_environment = excluded.apns_environment,
@@ -364,6 +376,9 @@ async function upsertLiveActivity(paths, input) {
           last_status_label = excluded.last_status_label,
           last_progress_text = excluded.last_progress_text,
           last_detail_text = excluded.last_detail_text,
+          last_todo_done_count = excluded.last_todo_done_count,
+          last_todo_total_count = excluded.last_todo_total_count,
+          last_todo_progress_text = excluded.last_todo_progress_text,
           last_visible_updated_at = excluded.last_visible_updated_at,
           push_count = 0,
           started_at = excluded.started_at,
@@ -390,6 +405,9 @@ async function upsertLiveActivity(paths, input) {
         restoreState?.statusLabel ?? null,
         restoreState?.progressText ?? null,
         restoreState?.detailText ?? null,
+        restoreState?.todoDoneCount ?? null,
+        restoreState?.todoTotalCount ?? null,
+        restoreState?.todoProgressText ?? null,
         restoreState?.updatedAt ?? null,
         input.startedAt,
         now,
@@ -481,6 +499,9 @@ async function updateLiveActivityPushState(paths, input) {
           last_status_label = ?,
           last_progress_text = ?,
           last_detail_text = ?,
+          last_todo_done_count = ?,
+          last_todo_total_count = ?,
+          last_todo_progress_text = ?,
           last_visible_updated_at = ?,
           push_count = push_count + 1,
           status = CASE WHEN ? THEN 'ended' ELSE status END,
@@ -495,6 +516,9 @@ async function updateLiveActivityPushState(paths, input) {
       normalizeNullableText(input.statusLabel),
       normalizeNullableText(input.progressText),
       normalizeNullableText(input.detailText),
+      normalizeNullableCount(input.todoDoneCount),
+      normalizeNullableCount(input.todoTotalCount),
+      normalizeNullableText(input.todoProgressText),
       input.visibleUpdatedAt,
       input.terminal ? 1 : 0,
       input.terminal ? 1 : 0,
@@ -1343,6 +1367,9 @@ function liveActivityFromRow(row) {
     lastStatusLabel: readNullableString(row, "last_status_label"),
     lastProgressText: readNullableString(row, "last_progress_text"),
     lastDetailText: readNullableString(row, "last_detail_text"),
+    lastTodoDoneCount: readNullableNumber(row, "last_todo_done_count"),
+    lastTodoTotalCount: readNullableNumber(row, "last_todo_total_count"),
+    lastTodoProgressText: readNullableString(row, "last_todo_progress_text"),
     lastVisibleUpdatedAt: readNullableString(row, "last_visible_updated_at"),
     pushCount: readNumber(row, "push_count"),
     startedAt,
@@ -1358,14 +1385,38 @@ function liveActivityRestoreStateFromRow(row) {
   if (!phase || !statusLabel || !progressText) {
     return null;
   }
-  return {
+  return sanitizeLiveActivityRestoreState({
     phase,
     statusLabel,
     progressText,
     detailText: readNullableString(row, "last_detail_text"),
+    todoDoneCount: readNullableNumber(row, "last_todo_done_count"),
+    todoTotalCount: readNullableNumber(row, "last_todo_total_count"),
+    todoProgressText: readNullableString(row, "last_todo_progress_text"),
     updatedAt: readNullableString(row, "last_visible_updated_at") ?? readNullableString(row, "updated_at")
+  });
+}
+function sanitizeLiveActivityRestoreState(state) {
+  if (!isCompletedTodoProgress(state.todoDoneCount, state.todoTotalCount)) {
+    return state;
+  }
+  return {
+    ...state,
+    todoDoneCount: null,
+    todoTotalCount: null,
+    todoProgressText: null
   };
 }
+function isCompletedTodoProgress(doneCount, totalCount) {
+  if (typeof doneCount !== "number" || !Number.isFinite(doneCount) || typeof totalCount !== "number" || !Number.isFinite(totalCount)) {
+    return false;
+  }
+  const normalizedTotal = Math.max(0, Math.trunc(totalCount));
+  if (normalizedTotal <= 0) {
+    return false;
+  }
+  return Math.max(0, Math.trunc(doneCount)) >= normalizedTotal;
+}
 function isLiveActivityStatus(value) {
   return value === "active" || value === "ended" || value === "expired" || value === "invalid";
 }
@@ -1373,6 +1424,12 @@ function normalizeNullableText(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
 }
+function normalizeNullableCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return null;
+  }
+  return Math.max(0, Math.trunc(value));
+}
 function rollback(db) {
   try {
     db.exec("ROLLBACK");
@@ -1393,6 +1450,20 @@ function readNumber(row, key) {
   }
   return 0;
 }
+function readNullableNumber(row, key) {
+  const value = row?.[key];
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.trunc(value);
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? Math.trunc(parsed) : null;
+  }
+  return null;
+}
 function readString(row, key) {
   const value = row?.[key];
   return typeof value === "string" && value.trim() ? value : void 0;
@@ -2600,6 +2671,7 @@ var AUTH_BACKED_MODEL_PROVIDERS = [
 var AUTH_BACKED_MODEL_PROVIDER_BY_KEY = new Map(
   AUTH_BACKED_MODEL_PROVIDERS.map((provider) => [provider.provider, provider])
 );
+var RESERVED_PROVIDER_CONFIG_KEYS = /* @__PURE__ */ new Set(["auto", "main"]);
 function isAuthBackedModelProviderKey(provider) {
   return AUTH_BACKED_MODEL_PROVIDER_BY_KEY.has(provider.trim());
 }
@@ -2859,6 +2931,7 @@ async function readHermesModelConfig(profileName = "default", configPath = resol
 }
 async function listHermesModelConfigs(profileName = "default", configPath = resolveHermesConfigPath(profileName)) {
   const { config } = await readHermesConfigDocument(configPath);
+  ensureProvidersRecordWithLegacyMigration(config);
   const env = await readHermesEnvFile(profileName);
   const defaultModel = readModelConfig(config.model).model ?? null;
   const defaultReasoningEffort = readProfileReasoningEffort(config);
@@ -3556,6 +3629,7 @@ async function deleteHermesModelConfig(input, profileName = "default", configPat
     throw new Error("model id is required");
   }
   const { document, config, existingRaw } = await readHermesConfigDocument(configPath);
+  ensureProvidersRecordWithLegacyMigration(config);
   const env = await readHermesEnvFile(profileName);
   const authBackedProviders = await readHermesAuthBackedProviderState(profileName);
   const existingModels = readManagedModelConfigs(
@@ -3669,6 +3743,7 @@ async function saveHermesModelDefaults(input, profileName = "default", configPat
     );
   }
   const { document, config, existingRaw } = await readHermesConfigDocument(configPath);
+  ensureProvidersRecordWithLegacyMigration(config);
   const env = await readHermesEnvFile(profileName);
   const authBackedProviders = await readHermesAuthBackedProviderState(profileName);
   if (taskModelId) {
@@ -4352,10 +4427,32 @@ function ensureProvidersRecordWithLegacyMigration(config) {
     providers[providerKey] = providers[providerKey] ? mergeProviderConfig(toRecord(providers[providerKey]), nextConfig) : nextConfig;
   }
   delete config.custom_providers;
-  const providerAliases = mergeDuplicateProviderConfigs(providers);
+  const providerAliases = renameReservedProviderConfigs(providers);
+  mergeProviderAliases(providerAliases, mergeDuplicateProviderConfigs(providers));
   rewriteProviderReferences(config, providerAliases);
   return providers;
 }
+function renameReservedProviderConfigs(providers) {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(providers)) {
+    if (!isReservedProviderConfigKey(key)) {
+      continue;
+    }
+    const nextKey = uniqueProviderConfigKey(
+      `${slugifyProviderKey(key)}-provider`,
+      providers
+    );
+    providers[nextKey] = providers[key];
+    delete providers[key];
+    aliases.set(key, nextKey);
+  }
+  return aliases;
+}
+function mergeProviderAliases(aliases, nextAliases) {
+  for (const [from, to] of nextAliases) {
+    aliases.set(from, to);
+  }
+}
 function mergeDuplicateProviderConfigs(providers) {
   const groupKeys = /* @__PURE__ */ new Map();
   const aliases = /* @__PURE__ */ new Map();
@@ -4545,14 +4642,18 @@ function providerConfigKeyBase(provider, providerName, baseUrl) {
   return slugifyProviderKey(fromProvider || fromName || host || "provider");
 }
 function uniqueProviderConfigKey(base, existing) {
-  let key = base || "provider";
+  const normalizedBase = isReservedProviderConfigKey(base) ? `${base}-provider` : base;
+  let key = normalizedBase || "provider";
   let index = 2;
-  while (Object.prototype.hasOwnProperty.call(existing, key)) {
-    key = `${base}-${index}`;
+  while (isReservedProviderConfigKey(key) || Object.prototype.hasOwnProperty.call(existing, key)) {
+    key = `${normalizedBase}-${index}`;
     index += 1;
   }
   return key;
 }
+function isReservedProviderConfigKey(key) {
+  return RESERVED_PROVIDER_CONFIG_KEYS.has(key.trim().toLowerCase());
+}
 function slugifyProviderKey(value) {
   const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "");
   return slug || "provider";
@@ -7524,7 +7625,7 @@ async function listCronOutputFiles(profileName, jobId) {
       orderTimeMs: fileStat.mtimeMs
     });
   }
-  return files.sort((left, right) => left.orderTimeMs - right.orderTimeMs).map(({ path: path37, mtime }) => ({ path: path37, mtime }));
+  return files.sort((left, right) => left.orderTimeMs - right.orderTimeMs).map(({ path: path38, mtime }) => ({ path: path38, mtime }));
 }
 function readCronOutputTimestamp(fileName) {
   const match = fileName.match(
@@ -7613,7 +7714,7 @@ function isConversationMissingError(error) {
 }
 
 // src/constants.ts
-var LINK_VERSION = "0.8.1-beta.1";
+var LINK_VERSION = "0.8.1-beta.3";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -7962,7 +8063,9 @@ async function reportLiveActivityEventToServerNow(options) {
   const event = liveActivityEventWithInheritedDetail(activity, options.event);
   const occurredAt = normalizeIso2(options.event.occurredAt) ?? (/* @__PURE__ */ new Date()).toISOString();
   const summaryHash = hashLiveActivitySummary(event);
-  const skipReason = resolveSkipReason(activity, event, summaryHash);
+  const skipReason = resolveSkipReason(activity, event, summaryHash, {
+    hasExplicitTodoProgress: hasLiveActivityTodoProgress(options.event)
+  });
   if (skipReason) {
     await options.logger.debug("live_activity_event_skipped", {
       activity_id: activity.activityId,
@@ -8001,6 +8104,9 @@ async function reportLiveActivityEventToServerNow(options) {
   addOptional2(payload, "status_label", event.statusLabel, 24);
   addOptional2(payload, "progress_text", event.progressText, 120);
   addOptional2(payload, "detail_text", event.detailText, 240);
+  addOptionalCount(payload, "todo_done_count", event.todoDoneCount);
+  addOptionalCount(payload, "todo_total_count", event.todoTotalCount);
+  addOptional2(payload, "todo_progress_text", event.todoProgressText, 16);
   addOptional2(payload, "language", activity.language, 16);
   addOptional2(payload, "privacy_level", activity.privacyLevel, 32);
   if (typeof event.requiresUserAction === "boolean") {
@@ -8037,7 +8143,10 @@ async function reportLiveActivityEventToServerNow(options) {
     terminal: event.terminal === true,
     statusLabel: event.statusLabel,
     progressText: event.progressText,
-    detailText: event.detailText
+    detailText: event.detailText,
+    todoDoneCount: event.todoDoneCount,
+    todoTotalCount: event.todoTotalCount,
+    todoProgressText: event.todoProgressText
   });
   const apnsReason = readApnsReason(body);
   if (apnsReason && shouldInvalidateLiveActivity(apnsReason)) {
@@ -8052,17 +8161,39 @@ function liveActivityEventWithInheritedDetail(activity, event) {
       phase,
       statusLabel: activity.lastStatusLabel?.trim() || event.statusLabel,
       progressText: activity.lastProgressText?.trim() || event.progressText,
-      detailText: activity.lastDetailText?.trim() || event.detailText
+      detailText: activity.lastDetailText?.trim() || event.detailText,
+      ...inheritedTodoProgress(activity, event)
     };
   }
+  const eventWithTodoProgress = {
+    ...event,
+    ...inheritedTodoProgress(activity, event)
+  };
   if (event.detailText?.trim() || !isToolPhase(event.phase)) {
-    return event;
+    return eventWithTodoProgress;
   }
   const detailText = activity.lastDetailText?.trim();
-  return detailText ? { ...event, detailText } : event;
+  return detailText ? { ...eventWithTodoProgress, detailText } : eventWithTodoProgress;
+}
+function inheritedTodoProgress(activity, event) {
+  if (typeof event.todoDoneCount === "number" || typeof event.todoTotalCount === "number") {
+    return {
+      todoDoneCount: event.todoDoneCount,
+      todoTotalCount: event.todoTotalCount,
+      todoProgressText: event.todoProgressText
+    };
+  }
+  if (typeof activity.lastTodoDoneCount === "number" && typeof activity.lastTodoTotalCount === "number") {
+    return {
+      todoDoneCount: activity.lastTodoDoneCount,
+      todoTotalCount: activity.lastTodoTotalCount,
+      todoProgressText: activity.lastTodoProgressText
+    };
+  }
+  return {};
 }
-function resolveSkipReason(activity, event, summaryHash) {
-  if (shouldThrottleLiveActivityEvent(activity, event)) {
+function resolveSkipReason(activity, event, summaryHash, options) {
+  if (shouldThrottleLiveActivityEvent(activity, event, options)) {
     return "push_interval_throttled";
   }
   if (activity.pushCount >= 60 && event.terminal !== true) {
@@ -8076,10 +8207,13 @@ function resolveSkipReason(activity, event, summaryHash) {
   }
   return null;
 }
-function shouldThrottleLiveActivityEvent(activity, event) {
+function shouldThrottleLiveActivityEvent(activity, event, options) {
   if (event.terminal === true || event.requiresUserAction === true || event.phase === "needs_input" || event.phase === "needs_approval") {
     return false;
   }
+  if (options?.hasExplicitTodoProgress === true) {
+    return false;
+  }
   if (isLiveActivityTitleUpdateEvent(event)) {
     return false;
   }
@@ -8121,6 +8255,9 @@ function isLiveActivityTitleUpdateEvent(event) {
 function isToolPhase(phase) {
   return phase === "using_tool" || phase === "tool_completed";
 }
+function hasLiveActivityTodoProgress(event) {
+  return typeof event.todoDoneCount === "number" && Number.isFinite(event.todoDoneCount) && typeof event.todoTotalCount === "number" && Number.isFinite(event.todoTotalCount);
+}
 function isLiveActivityPhase(value) {
   return value === "connecting" || value === "accepted" || value === "running" || value === "using_tool" || value === "tool_completed" || value === "needs_input" || value === "needs_approval" || value === "goal_running" || value === "goal_paused" || value === "context_compressing" || value === "context_compressed" || value === "context_compression_failed" || value === "context_compression_timed_out" || value === "paused" || value === "recovering" || value === "completed" || value === "failed" || value === "cancelled";
 }
@@ -8132,10 +8269,19 @@ function hashLiveActivitySummary(event) {
       event.statusLabel?.trim() ?? "",
       event.progressText?.trim() ?? "",
       event.detailText?.trim() ?? "",
+      event.todoDoneCount === void 0 || event.todoDoneCount === null ? "" : String(event.todoDoneCount),
+      event.todoTotalCount === void 0 || event.todoTotalCount === null ? "" : String(event.todoTotalCount),
+      event.todoProgressText?.trim() ?? "",
       event.terminal === true ? "terminal" : "update"
     ].join("|")
   ).digest("hex");
 }
+function addOptionalCount(payload, key, value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return;
+  }
+  payload[key] = Math.max(0, Math.trunc(value));
+}
 function addOptional2(payload, key, value, maxLength) {
   const normalized = value?.trim();
   if (normalized) {
@@ -10169,8 +10315,8 @@ import { spawn as spawn2 } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
 import { readFile as readFile6, stat as stat5 } from "fs/promises";
 import net2 from "net";
-import path9 from "path";
-import { setTimeout as delay3 } from "timers/promises";
+import path10 from "path";
+import { setTimeout as delay4 } from "timers/promises";
 import WebSocket from "ws";
 
 // src/conversations/goal-state.ts
@@ -10319,7 +10465,235 @@ function normalizeGoalStatus(value) {
   }
 }
 
+// src/hermes/tui-gateway-process-registry.ts
+import { execFile as execFile3 } from "child_process";
+import path9 from "path";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+var REGISTRY_VERSION2 = 1;
+var TERMINATE_GRACE_MS = 5e3;
+function tuiGatewayProcessRegistryPath(paths) {
+  return path9.join(paths.runDir, "tui-gateway-processes.json");
+}
+async function readRegisteredTuiGatewayProcesses(paths) {
+  return normalizeRegistry(
+    await readJsonFile(
+      tuiGatewayProcessRegistryPath(paths)
+    )
+  ).processes;
+}
+async function registerTuiGatewayProcess(paths, processRecord) {
+  await updateJsonFile(
+    tuiGatewayProcessRegistryPath(paths),
+    (current) => {
+      const registry = normalizeRegistry(current);
+      return {
+        version: REGISTRY_VERSION2,
+        processes: [
+          ...registry.processes.filter(
+            (item) => item.profile !== processRecord.profile && item.pid !== processRecord.pid
+          ),
+          processRecord
+        ]
+      };
+    }
+  );
+}
+async function unregisterTuiGatewayProcess(paths, input) {
+  await updateJsonFile(
+    tuiGatewayProcessRegistryPath(paths),
+    (current) => {
+      const registry = normalizeRegistry(current);
+      return {
+        version: REGISTRY_VERSION2,
+        processes: registry.processes.filter((item) => {
+          if (input.pid !== void 0) {
+            return item.pid !== input.pid;
+          }
+          if (input.profile !== void 0) {
+            return item.profile !== input.profile;
+          }
+          return true;
+        })
+      };
+    }
+  );
+}
+async function cleanupRegisteredTuiGatewayProcesses(input) {
+  const excludePids = new Set(
+    [...input.excludePids ?? []].filter(
+      (pid) => typeof pid === "number" && Number.isInteger(pid) && pid > 0
+    )
+  );
+  const processes = await readRegisteredTuiGatewayProcesses(input.paths);
+  const kept = [];
+  const result = {
+    stopped: [],
+    missing: [],
+    skipped: []
+  };
+  for (const processRecord of processes) {
+    if (excludePids.has(processRecord.pid)) {
+      kept.push(processRecord);
+      result.skipped.push({ process: processRecord, reason: "active_backend" });
+      continue;
+    }
+    const state = await inspectRegisteredProcess(processRecord);
+    if (!state.alive) {
+      result.missing.push(processRecord);
+      continue;
+    }
+    if (!state.matches) {
+      kept.push(processRecord);
+      result.skipped.push({
+        process: processRecord,
+        reason: state.reason ?? "command_mismatch"
+      });
+      void input.logger?.warn("tui_gateway_registry_cleanup_skipped", {
+        pid: processRecord.pid,
+        profile: processRecord.profile,
+        port: processRecord.port,
+        reason: state.reason ?? "command_mismatch",
+        command_line: state.commandLine ?? null
+      });
+      continue;
+    }
+    const stopped = await terminatePid(processRecord.pid);
+    if (stopped) {
+      result.stopped.push(processRecord);
+      void input.logger?.warn("tui_gateway_registered_process_stopped", {
+        pid: processRecord.pid,
+        profile: processRecord.profile,
+        port: processRecord.port
+      });
+    } else {
+      kept.push(processRecord);
+      result.skipped.push({ process: processRecord, reason: "terminate_failed" });
+      void input.logger?.warn("tui_gateway_registered_process_stop_failed", {
+        pid: processRecord.pid,
+        profile: processRecord.profile,
+        port: processRecord.port
+      });
+    }
+  }
+  await writeJsonFile(tuiGatewayProcessRegistryPath(input.paths), {
+    version: REGISTRY_VERSION2,
+    processes: kept
+  });
+  return result;
+}
+async function inspectRegisteredProcess(processRecord) {
+  if (!isProcessAlive(processRecord.pid)) {
+    return { alive: false, matches: false };
+  }
+  const commandLine = await readProcessCommandLine(processRecord.pid);
+  if (!commandLine) {
+    return {
+      alive: true,
+      matches: false,
+      reason: "command_unavailable"
+    };
+  }
+  if (!commandLineMatchesRecord(commandLine, processRecord)) {
+    return {
+      alive: true,
+      matches: false,
+      reason: "command_mismatch",
+      commandLine
+    };
+  }
+  return { alive: true, matches: true, commandLine };
+}
+async function readProcessCommandLine(pid) {
+  if (process.platform === "win32") {
+    return null;
+  }
+  try {
+    const { stdout } = await execFileAsync3(
+      "ps",
+      ["-p", String(pid), "-o", "command="],
+      {
+        timeout: 1e3,
+        windowsHide: true,
+        maxBuffer: 64 * 1024
+      }
+    );
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function commandLineMatchesRecord(commandLine, processRecord) {
+  return /\bhermes\b/u.test(commandLine) && /\bdashboard\b/u.test(commandLine) && hasCommandArgument(commandLine, "--host", "127.0.0.1") && hasCommandArgument(commandLine, "--port", String(processRecord.port));
+}
+function hasCommandArgument(commandLine, name, value) {
+  return commandLine.includes(`${name} ${value}`) || commandLine.includes(`${name}=${value}`);
+}
+async function terminatePid(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return !isProcessAlive(pid);
+  }
+  if (await waitForPidExit(pid, TERMINATE_GRACE_MS)) {
+    return true;
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    return !isProcessAlive(pid);
+  }
+  return await waitForPidExit(pid, 1e3);
+}
+async function waitForPidExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) {
+      return true;
+    }
+    await delay3(100);
+  }
+  return !isProcessAlive(pid);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeRegistry(value) {
+  if (!value || !Array.isArray(value.processes)) {
+    return { version: REGISTRY_VERSION2, processes: [] };
+  }
+  return {
+    version: REGISTRY_VERSION2,
+    processes: value.processes.filter(isProcessRecord)
+  };
+}
+function isProcessRecord(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return record.owner === "hermeslink" && Number.isInteger(record.pid) && record.pid > 0 && typeof record.profile === "string" && record.profile.length > 0 && Number.isInteger(record.port) && record.port > 0 && typeof record.command === "string" && Array.isArray(record.args) && record.args.every((item) => typeof item === "string") && typeof record.runtime_home === "string" && typeof record.started_at === "string";
+}
+function delay3(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+
 // src/hermes/tui-gateway-rpc.ts
+var TuiGatewaySessionBusyError = class extends LinkHttpError {
+  constructor(message, details = { profileName: "default" }) {
+    super(409, "tui_gateway_session_busy", message);
+    this.details = details;
+  }
+  details;
+};
 var CONNECT_TIMEOUT_MS = 15e3;
 var REQUEST_TIMEOUT_MS = 12e4;
 var USAGE_REQUEST_TIMEOUT_MS = 1e4;
@@ -10332,12 +10706,60 @@ var WS_HEARTBEAT_INTERVAL_MS = 6e4;
 var WS_RECONNECT_BASE_DELAY_MS = 1e3;
 var WS_RECONNECT_MAX_DELAY_MS = 15e3;
 var INTERRUPT_DRAIN_TIMEOUT_MS = 15e3;
+var SESSION_BUSY_RETRY_TIMEOUT_MS = 6e3;
+var SESSION_BUSY_RETRY_INTERVAL_MS = 150;
 var PROFILE_NAME_PATTERN2 = /^[a-zA-Z0-9._-]{1,64}$/u;
 var backendEntries = /* @__PURE__ */ new Map();
 var backendStarts = /* @__PURE__ */ new Map();
 var clients = /* @__PURE__ */ new Map();
 var sessionRefs = /* @__PURE__ */ new Map();
 var backendReaper = null;
+function isTuiGatewaySessionBusyError(error) {
+  if (error instanceof TuiGatewaySessionBusyError) {
+    return true;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return /session busy/i.test(message);
+}
+function createTuiGatewayRpcError(error) {
+  const message = error?.message ?? "Hermes RPC failed";
+  if (error?.code === 4009 && /session busy/i.test(message)) {
+    return new TuiGatewaySessionBusyError(message);
+  }
+  return new Error(message);
+}
+function withBusyContext(error, details) {
+  if (error instanceof TuiGatewaySessionBusyError) {
+    return new TuiGatewaySessionBusyError(error.message, {
+      ...error.details,
+      ...details
+    });
+  }
+  if (isTuiGatewaySessionBusyError(error)) {
+    return new TuiGatewaySessionBusyError(
+      error instanceof Error ? error.message : String(error),
+      details
+    );
+  }
+  return error instanceof Error ? error : new Error(String(error));
+}
+async function withSessionBusyRetry(call, signal) {
+  const deadline = Date.now() + SESSION_BUSY_RETRY_TIMEOUT_MS;
+  for (; ; ) {
+    try {
+      return await call();
+    } catch (error) {
+      if (!isTuiGatewaySessionBusyError(error) || Date.now() >= deadline) {
+        throw error;
+      }
+      await delay4(
+        Math.min(SESSION_BUSY_RETRY_INTERVAL_MS, deadline - Date.now()),
+        void 0,
+        { signal }
+      );
+    }
+  }
+}
 async function streamTuiGatewayRun(input) {
   const profileName = normalizeProfileName2(input.profileName);
   const client = await getTuiGatewayClient({
@@ -10395,6 +10817,77 @@ async function interruptTuiGatewaySession(input) {
   });
   await client.interruptSession(sessionId);
 }
+async function readTuiGatewayLiveSession(input) {
+  const runtimeSessionId = input.runtimeSessionId?.trim();
+  const storedSessionId = input.storedSessionId?.trim();
+  if (!runtimeSessionId && !storedSessionId) {
+    return null;
+  }
+  const profileName = normalizeProfileName2(input.profileName);
+  const client = await getTuiGatewayClient({
+    profileName,
+    paths: input.paths,
+    logger: input.logger
+  });
+  try {
+    const result = await client.request(
+      "session.active_list",
+      runtimeSessionId ? { current_session_id: runtimeSessionId } : {},
+      1e4
+    );
+    const sessions = Array.isArray(result.sessions) ? result.sessions : [];
+    for (const item of sessions) {
+      const liveSession = normalizeTuiGatewayLiveSessionRecord(item);
+      if (!liveSession) {
+        continue;
+      }
+      const runtimeMatches = runtimeSessionId !== void 0 && liveSession.runtimeSessionId === runtimeSessionId;
+      const storedMatches = storedSessionId !== void 0 && liveSession.storedSessionId === storedSessionId;
+      if (!runtimeMatches && !storedMatches) {
+        continue;
+      }
+      return liveSession;
+    }
+  } catch (error) {
+    void input.logger?.debug("tui_gateway_live_session_read_failed", {
+      profile: profileName,
+      runtime_session_id: runtimeSessionId ?? null,
+      stored_session_id: storedSessionId ?? null,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  return null;
+}
+function normalizeTuiGatewayLiveSessionRecord(value) {
+  const record = toRecord3(value);
+  const runtimeId = readString5(record, "id");
+  if (!runtimeId) {
+    return null;
+  }
+  const storedId = readString5(record, "session_key") ?? readString5(record, "sessionKey");
+  const status = (readString5(record, "status") ?? "unknown").toLowerCase();
+  const inflight = typeof record.inflight === "object" && record.inflight !== null ? toRecord3(record.inflight) : void 0;
+  const running = readBoolean(record.running) || status === "working" || status === "waiting" || status === "starting" || inflight !== void 0 && Object.keys(inflight).length > 0;
+  const title = readString5(record, "title");
+  const preview = readString5(record, "preview");
+  const model = readString5(record, "model");
+  const lastActiveAt = readFiniteNumber(record.last_active);
+  const startedAt = readFiniteNumber(record.started_at);
+  return {
+    runtimeSessionId: runtimeId,
+    storedSessionId: storedId ?? runtimeId,
+    status,
+    running,
+    ...readBoolean(record.current) ? { current: true } : {},
+    ...title ? { title } : {},
+    ...preview ? { preview } : {},
+    ...model ? { model } : {},
+    ...lastActiveAt !== void 0 ? { lastActiveAt } : {},
+    ...startedAt !== void 0 ? { startedAt } : {},
+    ...inflight ? { inflight } : {},
+    raw: record
+  };
+}
 async function dispatchTuiGatewayCommand(input) {
   const profileName = normalizeProfileName2(input.profileName);
   const client = await getTuiGatewayClient({
@@ -10642,32 +11135,50 @@ async function setTuiGatewaySessionModelConfig(input) {
   }
   const raw = [];
   if (model) {
-    const result = await client.request(
-      "config.set",
-      {
-        session_id: started.runtimeSessionId,
-        key: "model",
-        value: formatSessionModelConfigValue(
-          model,
-          input.provider,
-          hasNativeSessionModelConfig
-        ),
-        confirm_expensive_model: true
-      },
-      REQUEST_TIMEOUT_MS
-    );
+    const result = await withSessionBusyRetry(
+      () => client.request(
+        "config.set",
+        {
+          session_id: started.runtimeSessionId,
+          key: "model",
+          value: formatSessionModelConfigValue(
+            model,
+            input.provider,
+            hasNativeSessionModelConfig
+          ),
+          confirm_expensive_model: true
+        },
+        REQUEST_TIMEOUT_MS
+      )
+    ).catch((error) => {
+      throw withBusyContext(error, {
+        profileName,
+        runtimeSessionId: started.runtimeSessionId,
+        storedSessionId: started.storedSessionId,
+        method: "config.set:model"
+      });
+    });
     raw.push(result);
   }
   if (reasoningEffort) {
-    const result = await client.request(
-      "config.set",
-      {
-        session_id: started.runtimeSessionId,
-        key: "reasoning",
-        value: reasoningEffort
-      },
-      REQUEST_TIMEOUT_MS
-    );
+    const result = await withSessionBusyRetry(
+      () => client.request(
+        "config.set",
+        {
+          session_id: started.runtimeSessionId,
+          key: "reasoning",
+          value: reasoningEffort
+        },
+        REQUEST_TIMEOUT_MS
+      )
+    ).catch((error) => {
+      throw withBusyContext(error, {
+        profileName,
+        runtimeSessionId: started.runtimeSessionId,
+        storedSessionId: started.storedSessionId,
+        method: "config.set:reasoning"
+      });
+    });
     raw.push(result);
   }
   rememberSessionRef(profileName, input.hermesSessionId, started);
@@ -10705,12 +11216,12 @@ async function restartTuiGatewayBackend(input) {
   const entry = backendEntries.get(profileName);
   backendEntries.delete(profileName);
   backendStarts.delete(profileName);
-  if (entry && entry.process.exitCode === null) {
-    entry.process.kill("SIGTERM");
-    await waitForProcessExit(entry.process, BACKEND_RESTART_GRACE_MS);
-    if (entry.process.exitCode === null) {
-      entry.process.kill("SIGKILL");
-    }
+  if (entry) {
+    await terminateBackendEntry(entry, {
+      paths: input.paths,
+      logger: input.logger,
+      graceMs: BACKEND_RESTART_GRACE_MS
+    });
   }
   void input.logger?.warn("tui_gateway_backend_restart_requested", {
     profile: profileName,
@@ -10835,23 +11346,58 @@ async function readTuiGatewayStatus(input = {}) {
     };
   }
 }
-function closeTuiGatewayBackends() {
+async function closeTuiGatewayBackends(input = {}) {
   for (const client of clients.values()) {
     client.close();
   }
   clients.clear();
   sessionRefs.clear();
-  for (const entry of backendEntries.values()) {
-    if (!entry.process.killed) {
-      entry.process.kill();
-    }
-  }
+  const entries = [...backendEntries.values()];
   backendEntries.clear();
+  await Promise.all(
+    entries.map(
+      (entry) => terminateBackendEntry(entry, {
+        paths: input.paths,
+        logger: input.logger
+      })
+    )
+  );
+  if (input.cleanupRegistry && input.paths) {
+    await cleanupRegisteredTuiGatewayProcesses({
+      paths: input.paths,
+      logger: input.logger
+    });
+  }
   if (backendReaper) {
     clearInterval(backendReaper);
     backendReaper = null;
   }
 }
+async function terminateBackendEntry(entry, input = {}) {
+  if (entry.process.exitCode === null && entry.process.signalCode === null) {
+    if (!entry.process.killed) {
+      entry.process.kill("SIGTERM");
+    }
+    await waitForProcessExit(
+      entry.process,
+      input.graceMs ?? BACKEND_RESTART_GRACE_MS
+    );
+    if (entry.process.exitCode === null && entry.process.signalCode === null) {
+      entry.process.kill("SIGKILL");
+      await waitForProcessExit(entry.process, 1e3);
+    }
+  }
+  await unregisterTuiGatewayProcess(input.paths ?? entry.paths, {
+    pid: entry.process.pid ?? void 0,
+    profile: entry.profile
+  }).catch((error) => {
+    void input.logger?.debug("tui_gateway_registry_unregister_failed", {
+      profile: entry.profile,
+      pid: entry.process.pid ?? null,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  });
+}
 function formatSessionModelConfigValue(model, provider, sessionOnly = false) {
   const suffix = sessionOnly ? " --session" : "";
   const normalizedProvider = provider?.trim();
@@ -11032,7 +11578,7 @@ async function startTuiGatewayBackend(input) {
   ];
   const logWriter = createRotatingTextLogWriter({
     paths,
-    fileName: path9.basename(getGatewayRuntimeLogFile(paths))
+    fileName: path10.basename(getGatewayRuntimeLogFile(paths))
   });
   const hermesBin = resolveHermesBin();
   const child = spawn2(hermesBin, args, {
@@ -11053,6 +11599,16 @@ async function startTuiGatewayBackend(input) {
     clients.get(profileName)?.close();
     clients.delete(profileName);
     backendEntries.delete(profileName);
+    void unregisterTuiGatewayProcess(paths, {
+      pid: child.pid ?? void 0,
+      profile: profileName
+    }).catch((error) => {
+      void input.logger?.debug("tui_gateway_registry_unregister_failed", {
+        profile: profileName,
+        pid: child.pid ?? null,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
     void input.logger?.warn("tui_gateway_backend_exited", {
       profile: profileName,
       pid: child.pid ?? null,
@@ -11083,6 +11639,32 @@ async function startTuiGatewayBackend(input) {
     await logWriter.flush().catch(() => void 0);
     throw error;
   }
+  if (!child.pid) {
+    child.kill();
+    await logWriter.flush().catch(() => void 0);
+    throw new LinkHttpError(
+      503,
+      "tui_gateway_backend_unavailable",
+      "Hermes dashboard backend started without a process id."
+    );
+  }
+  try {
+    await registerTuiGatewayProcess(paths, {
+      owner: "hermeslink",
+      pid: child.pid,
+      profile: profileName,
+      port,
+      command: hermesBin,
+      args,
+      runtime_home: paths.homeDir,
+      started_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch (error) {
+    child.kill();
+    await waitForProcessExit(child, BACKEND_RESTART_GRACE_MS);
+    await logWriter.flush().catch(() => void 0);
+    throw error;
+  }
   const entry = {
     profile: profileName,
     port,
@@ -11090,6 +11672,7 @@ async function startTuiGatewayBackend(input) {
     baseUrl,
     wsUrl,
     process: child,
+    paths,
     logPath: logWriter.filePath,
     startedAt: Date.now(),
     lastActiveAt: Date.now()
@@ -11267,12 +11850,21 @@ var TuiGatewayClient = class {
       cleanup();
     };
     input.signal?.addEventListener("abort", abort, { once: true });
-    void this.request(
-      "prompt.submit",
-      { session_id: input.sessionId, text: input.text },
-      PROMPT_SUBMIT_TIMEOUT_MS
+    void withSessionBusyRetry(
+      () => this.request(
+        "prompt.submit",
+        { session_id: input.sessionId, text: input.text },
+        PROMPT_SUBMIT_TIMEOUT_MS
+      ),
+      input.signal
     ).catch((error) => {
-      queue.pushError(error);
+      queue.pushError(
+        withBusyContext(error, {
+          profileName: this.profileName,
+          runtimeSessionId: input.sessionId,
+          method: "prompt.submit"
+        })
+      );
     });
     queue.closed.finally(cleanup).catch(() => void 0);
     return queue;
@@ -11406,7 +11998,7 @@ var TuiGatewayClient = class {
       this.pending.delete(frame.id);
       clearTimeout(pending.timer);
       if (frame.error) {
-        pending.reject(new Error(frame.error.message ?? "Hermes RPC failed"));
+        pending.reject(createTuiGatewayRpcError(frame.error));
       } else {
         pending.resolve(frame.result);
       }
@@ -11527,14 +12119,14 @@ async function readCurrentStoredSessionId(client, runtimeSessionId, logger) {
   return null;
 }
 async function waitForProcessExit(child, timeoutMs) {
-  if (child.killed || child.exitCode !== null) {
+  if (child.exitCode !== null || child.signalCode !== null) {
     return;
   }
   await Promise.race([
     new Promise((resolve) => {
       child.once("exit", () => resolve());
     }),
-    delay3(timeoutMs).then(() => void 0)
+    delay4(timeoutMs).then(() => void 0)
   ]);
 }
 var GatewayEventQueue = class {
@@ -11969,7 +12561,7 @@ async function waitForDashboardReady(baseUrl, token, logPath, signal) {
     } catch (error) {
       lastError = error;
     }
-    await delay3(250, void 0, { signal }).catch(() => void 0);
+    await delay4(250, void 0, { signal }).catch(() => void 0);
   }
   throw new LinkHttpError(
     503,
@@ -12056,23 +12648,28 @@ function startBackendReaper() {
     return;
   }
   backendReaper = setInterval(() => {
-    const now = Date.now();
-    for (const [profile, entry] of backendEntries) {
-      if (now - entry.lastActiveAt < IDLE_BACKEND_TTL_MS) {
-        continue;
-      }
-      clients.get(profile)?.close();
-      clients.delete(profile);
-      backendEntries.delete(profile);
-      entry.process.kill();
-    }
-    if (backendEntries.size === 0 && backendReaper) {
-      clearInterval(backendReaper);
-      backendReaper = null;
-    }
+    void reapIdleBackends();
   }, 6e4);
   backendReaper.unref?.();
 }
+async function reapIdleBackends() {
+  const now = Date.now();
+  const staleEntries = [];
+  for (const [profile, entry] of backendEntries) {
+    if (now - entry.lastActiveAt < IDLE_BACKEND_TTL_MS) {
+      continue;
+    }
+    clients.get(profile)?.close();
+    clients.delete(profile);
+    backendEntries.delete(profile);
+    staleEntries.push(entry);
+  }
+  await Promise.all(staleEntries.map((entry) => terminateBackendEntry(entry)));
+  if (backendEntries.size === 0 && backendReaper) {
+    clearInterval(backendReaper);
+    backendReaper = null;
+  }
+}
 function normalizeProfileName2(profileName) {
   const value = profileName?.trim() || "default";
   if (!PROFILE_NAME_PATTERN2.test(value)) {
@@ -12102,6 +12699,19 @@ function readString5(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
+function readBoolean(value) {
+  return value === true || value === "true" || value === 1;
+}
+function readFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
 function readStringList2(value) {
   if (!Array.isArray(value)) {
     return [];
@@ -12867,11 +13477,11 @@ function workspaceNotFound() {
 // src/conversations/blob-store.ts
 import { randomUUID as randomUUID5 } from "crypto";
 import { mkdir as mkdir6, readFile as readFile7, readdir as readdir4, rm as rm3, stat as stat6, writeFile } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 
 // src/conversations/media.ts
 import { createHash as createHash4 } from "crypto";
-import path10 from "path";
+import path11 from "path";
 
 // src/conversations/delivery-contract.ts
 var HERMES_LINK_DELIVERY_TAG_PATTERN = /<hermes_link_delivery>\s*(\{[\s\S]*?\})\s*<\/hermes_link_delivery>/giu;
@@ -12961,7 +13571,7 @@ function cleanMessageTextParts(message) {
   }
 }
 function inferMimeType(filePath) {
-  const extension = path10.extname(filePath).toLowerCase();
+  const extension = path11.extname(filePath).toLowerCase();
   return {
     ".png": "image/png",
     ".jpg": "image/jpeg",
@@ -13085,7 +13695,7 @@ function mediaSourceKey(sourcePath) {
   return createHash4("sha256").update(resolveMediaSourcePath(sourcePath)).digest("hex").slice(0, 32);
 }
 function sanitizeFilename(value, fallback) {
-  const base = path10.basename((value ?? "").replace(/[\r\n\t]/gu, " ").trim());
+  const base = path11.basename((value ?? "").replace(/[\r\n\t]/gu, " ").trim());
   const safe = base.replace(/[/:\\]/gu, "_").slice(0, 200).trim();
   return safe || fallback;
 }
@@ -13114,9 +13724,9 @@ function isBlobReferencedByMessages(snapshot, blobId) {
 }
 function resolveMediaSourcePath(sourcePath) {
   const trimmed = sourcePath.trim();
-  const expanded = trimmed.startsWith("~/") ? path10.join(process.env.HOME ?? "", trimmed.slice(2)) : trimmed;
-  const resolved = path10.resolve(expanded);
-  if (!path10.isAbsolute(expanded)) {
+  const expanded = trimmed.startsWith("~/") ? path11.join(process.env.HOME ?? "", trimmed.slice(2)) : trimmed;
+  const resolved = path11.resolve(expanded);
+  if (!path11.isAbsolute(expanded)) {
     throw new LinkHttpError(
       400,
       "media_source_path_not_absolute",
@@ -13311,7 +13921,7 @@ function normalizeConversationIds(conversationIds) {
 }
 function blobPath(paths, blobId) {
   assertValidBlobId(blobId);
-  return path11.join(paths.blobsDir, `${blobId}.bin`);
+  return path12.join(paths.blobsDir, `${blobId}.bin`);
 }
 async function writeConversationBlob(paths, conversationId, input, options) {
   assertValidConversationId(conversationId);
@@ -13320,7 +13930,7 @@ async function writeConversationBlob(paths, conversationId, input, options) {
   }
   const id = `blob_${randomUUID5().replaceAll("-", "")}`;
   const filePath = blobPath(paths, id);
-  await mkdir6(path11.dirname(filePath), { recursive: true, mode: 448 });
+  await mkdir6(path12.dirname(filePath), { recursive: true, mode: 448 });
   await writeFile(filePath, input.bytes, { mode: 384 });
   const blob = {
     id,
@@ -13396,7 +14006,7 @@ async function materializeConversationBlob(paths, conversationId, blobId, manife
     }
   }
   const targetDir = conversationAttachmentsDir(paths, conversationId);
-  const targetPath = path11.join(
+  const targetPath = path12.join(
     targetDir,
     materializedAttachmentFilename(blobId, manifest.filename ?? blobId)
   );
@@ -13449,7 +14059,7 @@ async function listConversationBlobIds(paths, conversationId) {
       continue;
     }
     const manifest = await readJsonFile(
-      path11.join(paths.blobsDir, entry.name)
+      path12.join(paths.blobsDir, entry.name)
     ).catch(() => null);
     if (manifest?.conversation_ids?.includes(conversationId)) {
       blobIds.push(blobId);
@@ -13459,7 +14069,7 @@ async function listConversationBlobIds(paths, conversationId) {
 }
 function conversationAttachmentsDir(paths, conversationId) {
   assertValidConversationId(conversationId);
-  return path11.join(paths.conversationsDir, conversationId, "attachments");
+  return path12.join(paths.conversationsDir, conversationId, "attachments");
 }
 function isNodeError6(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
@@ -13471,7 +14081,7 @@ import { stat as stat8 } from "fs/promises";
 // src/hermes/model-provider-disconnects.ts
 import { stat as stat7 } from "fs/promises";
 import os5 from "os";
-import path12 from "path";
+import path13 from "path";
 async function markAuthBackedModelProviderDisconnected(paths, profileName, providerKey) {
   const profileKey = normalizeProfileName3(profileName);
   const provider = providerKey.trim();
@@ -13549,15 +14159,15 @@ function credentialFilesForProvider(profileName, providerKey) {
   const profileDir = resolveHermesProfileDir(normalizeProfileName3(profileName));
   switch (providerKey) {
     case "qwen-oauth":
-      return [path12.join(os5.homedir(), ".qwen", "oauth_creds.json")];
+      return [path13.join(os5.homedir(), ".qwen", "oauth_creds.json")];
     case "google-gemini-cli":
-      return [path12.join(profileDir, "auth", "google_oauth.json")];
+      return [path13.join(profileDir, "auth", "google_oauth.json")];
     default:
-      return [path12.join(profileDir, "auth.json")];
+      return [path13.join(profileDir, "auth.json")];
   }
 }
 function disconnectedProvidersPath(paths) {
-  return path12.join(paths.homeDir, "model-provider-disconnects.json");
+  return path13.join(paths.homeDir, "model-provider-disconnects.json");
 }
 function normalizeStore(value) {
   return {
@@ -14688,7 +15298,7 @@ function commandText(language, zh, en) {
 
 // src/conversations/delivery-staging.ts
 import { mkdir as mkdir7, rm as rm4 } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 async function prepareDeliveryStagingRunDir(paths, conversationId, runId) {
   const directory = deliveryStagingRunDir(paths, conversationId, runId);
   await mkdir7(directory, { recursive: true, mode: 448 });
@@ -14701,14 +15311,14 @@ async function removeConversationDeliveryStaging(paths, conversationId) {
   });
 }
 function deliveryStagingRunDir(paths, conversationId, runId) {
-  return path13.join(
+  return path14.join(
     deliveryStagingConversationDir(paths, conversationId),
     safePathSegment(runId, "run")
   );
 }
 function deliveryStagingConversationDir(paths, conversationId) {
   assertValidConversationId(conversationId);
-  return path13.join(paths.conversationsDir, conversationId, "delivery-staging");
+  return path14.join(paths.conversationsDir, conversationId, "delivery-staging");
 }
 function safePathSegment(value, fallback) {
   const safe = value.trim().replaceAll(/[^a-zA-Z0-9._-]/gu, "_");
@@ -14718,7 +15328,7 @@ function safePathSegment(value, fallback) {
 // src/conversations/conversation-archive-plans.ts
 import { randomUUID as randomUUID7 } from "crypto";
 import { mkdir as mkdir8 } from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 var PLAN_ID_PATTERN = /^archive_[a-f0-9]{32}$/u;
 var ConversationArchivePlanStore = class {
   constructor(paths) {
@@ -14761,10 +15371,10 @@ var ConversationArchivePlanStore = class {
     await writeJsonFile(this.planPath(normalizedPlanId), plan);
   }
   plansDir() {
-    return path14.join(this.paths.indexesDir, "conversation-archive-plans");
+    return path15.join(this.paths.indexesDir, "conversation-archive-plans");
   }
   planPath(planId) {
-    return path14.join(this.plansDir(), `${planId}.json`);
+    return path15.join(this.plansDir(), `${planId}.json`);
   }
 };
 function normalizePlanId(planId) {
@@ -14782,7 +15392,7 @@ function normalizePlanId(planId) {
 // src/conversations/conversation-clear-plans.ts
 import { randomUUID as randomUUID8 } from "crypto";
 import { mkdir as mkdir9 } from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 var PLAN_ID_PATTERN2 = /^clear_[a-f0-9]{32}$/u;
 var ConversationClearPlanStore = class {
   constructor(paths) {
@@ -14826,10 +15436,10 @@ var ConversationClearPlanStore = class {
     await writeJsonFile(this.planPath(normalizedPlanId), plan);
   }
   plansDir() {
-    return path15.join(this.paths.indexesDir, "conversation-clear-plans");
+    return path16.join(this.paths.indexesDir, "conversation-clear-plans");
   }
   planPath(planId) {
-    return path15.join(this.plansDir(), `${planId}.json`);
+    return path16.join(this.plansDir(), `${planId}.json`);
   }
 };
 function normalizePlanId2(planId) {
@@ -15684,14 +16294,14 @@ function readAttachmentWaveform(attachment) {
 
 // src/hermes/session-title.ts
 import { stat as stat9 } from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 async function readHermesSessionTitle(sessionId, paths, profileName) {
   const trimmedSessionId = sessionId.trim();
   if (!trimmedSessionId) {
     return void 0;
   }
   const resolvedProfileName = isValidProfileName(profileName) ? profileName : "default";
-  const dbPath = path16.join(
+  const dbPath = path17.join(
     resolveHermesProfileDir(resolvedProfileName),
     "state.db"
   );
@@ -15712,7 +16322,7 @@ async function readHermesCompressionTip(sessionId, paths, profileName) {
     return void 0;
   }
   const resolvedProfileName = isValidProfileName(profileName) ? profileName : "default";
-  const dbPath = path16.join(
+  const dbPath = path17.join(
     resolveHermesProfileDir(resolvedProfileName),
     "state.db"
   );
@@ -15840,12 +16450,12 @@ var ConversationMetadataCoordinator = class {
     return { ...next, last_event_seq: event.seq, updated_at: event.created_at };
   }
   scheduleGeneratedTitleRefresh(conversationId) {
-    for (const delay5 of GENERATED_TITLE_RETRY_DELAYS_MS) {
+    for (const delay6 of GENERATED_TITLE_RETRY_DELAYS_MS) {
       setTimeout(() => {
         void this.generateTitleFromFirstRound(conversationId).catch(
           () => void 0
         );
-      }, delay5);
+      }, delay6);
     }
   }
   async renameConversation(conversationId, title, input) {
@@ -16145,7 +16755,7 @@ function stripCompressionTitleSuffix(value) {
 
 // src/conversations/history-builder.ts
 import { readFile as readFile8, stat as stat10 } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 var HISTORY_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
 var HERMES_HISTORY_COLUMNS = [
   "role",
@@ -16217,13 +16827,13 @@ async function readHermesTranscriptHistory(sessionId, profileName) {
   }
   const normalizedProfileName = isValidProfileName2(profileName) ? profileName : "default";
   const profileDir = resolveHermesProfileDir(normalizedProfileName);
-  const dbPath = path17.join(profileDir, "state.db");
+  const dbPath = path18.join(profileDir, "state.db");
   const sessionsDirConfig = await readHermesSessionsDir(normalizedProfileName).then((value) => ({
     sessionsDir: value.sessionsDir,
     configured: value.configured,
     configError: false
   })).catch(() => ({
-    sessionsDir: path17.join(profileDir, "sessions"),
+    sessionsDir: path18.join(profileDir, "sessions"),
     configured: false,
     configError: true
   }));
@@ -16399,8 +17009,8 @@ async function readFirstExistingFile(paths) {
 }
 function candidateTranscriptPaths(sessionsDir, sessionId, extension) {
   return [
-    path17.join(sessionsDir, `session_${sessionId}.${extension}`),
-    path17.join(sessionsDir, `${sessionId}.${extension}`)
+    path18.join(sessionsDir, `session_${sessionId}.${extension}`),
+    path18.join(sessionsDir, `${sessionId}.${extension}`)
   ];
 }
 function readHistoryRows(dbPath, sessionId) {
@@ -17037,7 +17647,10 @@ var ConversationOrchestrationCoordinator = class {
     );
   }
   startRunWorkerAndDrain(conversationId, runId, input) {
-    void this.deps.runLifecycle.startRunWorker(conversationId, runId, input).catch(async (error) => {
+    let shouldDrainQueue = true;
+    void this.deps.runLifecycle.startRunWorker(conversationId, runId, input).then((outcome) => {
+      shouldDrainQueue = outcome.shouldDrainQueue;
+    }).catch(async (error) => {
       if (isConversationNotFoundError(error)) {
         return;
       }
@@ -17063,6 +17676,9 @@ var ConversationOrchestrationCoordinator = class {
         });
       }
     }).finally(() => {
+      if (!shouldDrainQueue) {
+        return;
+      }
       void this.startNextQueuedRun(conversationId).catch((error) => {
         void this.deps.logger.warn("conversation_queue_drain_failed", {
           conversation_id: conversationId,
@@ -18356,6 +18972,10 @@ var APP_TOOL_EVENT_FIELDS_TO_DROP = /* @__PURE__ */ new Set([
   "message"
 ]);
 var LIFECYCLE_MARKER_FORMAT = "hermes-link-lifecycle-marker";
+var APP_VISIBLE_LIFECYCLE_MARKER_KINDS = /* @__PURE__ */ new Set([
+  "context_compression",
+  "goal_completion"
+]);
 function projectConversationAgentEvent(event, language = readLanguage(event.payload)) {
   if (!isAgentActivityEvent(event.type)) {
     return null;
@@ -18576,7 +19196,7 @@ function retainAppVisibleRaw(value) {
     return null;
   }
   const payload = toRecord8(raw.payload);
-  if (payload.kind !== "context_compression") {
+  if (typeof payload.kind !== "string" || !APP_VISIBLE_LIFECYCLE_MARKER_KINDS.has(payload.kind)) {
     return null;
   }
   return {
@@ -18942,11 +19562,14 @@ var ConversationQueryCoordinator = class {
       );
     }
     const startIndex = Math.max(0, endIndex - limit);
+    const events = await this.listEvents(conversationId, 0).catch(() => []);
     const messages2 = await this.hydrateAgentEventsForMessages(
       conversationId,
       snapshot.messages.slice(startIndex, endIndex),
-      snapshot
+      snapshot,
+      events
     );
+    const todoSnapshot = latestTodoSnapshotFromEvents(conversationId, events);
     return {
       messages: messages2,
       last_event_seq: manifest.last_event_seq,
@@ -18964,7 +19587,8 @@ var ConversationQueryCoordinator = class {
       },
       event_stream: buildConversationEventStreamState(snapshot),
       input_requests: pendingInputRequests(snapshot),
-      ...normalizeConversationGoalState(manifest.command_state?.goal) ? { goal: normalizeConversationGoalState(manifest.command_state?.goal) } : {}
+      ...normalizeConversationGoalState(manifest.command_state?.goal) ? { goal: normalizeConversationGoalState(manifest.command_state?.goal) } : {},
+      ...todoSnapshot ? { todo_snapshot: todoSnapshot } : {}
     };
   }
   async listEvents(conversationId, after = 0) {
@@ -18977,12 +19601,11 @@ var ConversationQueryCoordinator = class {
       profile ?? await readConversationProfileSummary(this.deps.paths, manifest)
     );
   }
-  async hydrateAgentEventsForMessages(conversationId, messages2, snapshot) {
+  async hydrateAgentEventsForMessages(conversationId, messages2, snapshot, events) {
     if (!messages2.some((message) => message.role === "assistant")) {
       return messages2;
     }
     const eventsByMessageId = /* @__PURE__ */ new Map();
-    const events = await this.listEvents(conversationId, 0).catch(() => []);
     for (const event of events) {
       if (!event.message_id) {
         continue;
@@ -19018,6 +19641,81 @@ var ConversationQueryCoordinator = class {
     });
   }
 };
+function latestTodoSnapshotFromEvents(conversationId, events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const snapshot = todoSnapshotFromEvent(conversationId, events[index]);
+    if (snapshot) {
+      return snapshot;
+    }
+  }
+  return null;
+}
+function todoSnapshotFromEvent(conversationId, event) {
+  const type = event.type.toLowerCase();
+  if (type !== "tool.completed" && type !== "tool.complete") {
+    return null;
+  }
+  const payload = readRecord(event.payload);
+  const toolName = readToolName(payload)?.toLowerCase();
+  if (toolName !== "todo") {
+    return null;
+  }
+  const todos = readTodoItems(payload.todos) ?? readTodoItems(readRecord(payload.result).todos) ?? readTodoItems(readRecord(payload.output).todos) ?? readTodoItems(readRecord(payload.content).todos);
+  if (!todos || todos.length === 0) {
+    return null;
+  }
+  return {
+    conversation_id: conversationId,
+    ...event.run_id ? { run_id: event.run_id } : {},
+    updated_at: event.created_at,
+    items: todos
+  };
+}
+function readTodoItems(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const items = value.map((item, index) => readTodoItem(item, index)).filter((item) => item !== null);
+  return items.length > 0 ? items : null;
+}
+function readTodoItem(value, index) {
+  const record = readRecord(value);
+  const content = readNonEmptyString(record.content) ?? readNonEmptyString(record.title);
+  const status = readTodoStatus(readNonEmptyString(record.status));
+  if (!content || !status) {
+    return null;
+  }
+  return {
+    id: readNonEmptyString(record.id) ?? `${index + 1}`,
+    content,
+    status
+  };
+}
+function readTodoStatus(value) {
+  switch (value?.trim().toLowerCase()) {
+    case "pending":
+      return "pending";
+    case "in_progress":
+    case "in-progress":
+    case "running":
+      return "in_progress";
+    case "completed":
+    case "complete":
+    case "done":
+      return "completed";
+    case "cancelled":
+    case "canceled":
+      return "cancelled";
+    default:
+      return null;
+  }
+}
+function readToolName(record) {
+  return readNonEmptyString(record.tool_name) ?? readNonEmptyString(record.toolName) ?? readNonEmptyString(record.name) ?? readNonEmptyString(record.tool) ?? readNonEmptyString(readRecord(record.tool).name);
+}
+function readRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
 function readRunLanguage(snapshot, runId) {
   if (!runId) {
     return null;
@@ -19830,7 +20528,7 @@ import {
   rm as rm5,
   writeFile as writeFile2
 } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 var ConversationStore = class {
   constructor(paths) {
     this.paths = paths;
@@ -19961,23 +20659,23 @@ var ConversationStore = class {
     return manifest != null && manifest.status !== "deleted_soft";
   }
   removeConversationAttachments(conversationId) {
-    return rm5(path18.join(this.conversationDir(conversationId), "attachments"), {
+    return rm5(path19.join(this.conversationDir(conversationId), "attachments"), {
       recursive: true,
       force: true
     });
   }
   conversationDir(conversationId) {
     assertValidConversationId(conversationId);
-    return path18.join(this.paths.conversationsDir, conversationId);
+    return path19.join(this.paths.conversationsDir, conversationId);
   }
   manifestPath(conversationId) {
-    return path18.join(this.conversationDir(conversationId), "manifest.json");
+    return path19.join(this.conversationDir(conversationId), "manifest.json");
   }
   snapshotPath(conversationId) {
-    return path18.join(this.conversationDir(conversationId), "snapshot.json");
+    return path19.join(this.conversationDir(conversationId), "snapshot.json");
   }
   eventsPath(conversationId) {
-    return path18.join(this.conversationDir(conversationId), "events.ndjson");
+    return path19.join(this.conversationDir(conversationId), "events.ndjson");
   }
 };
 function createEmptySnapshot2() {
@@ -19988,13 +20686,13 @@ function isNodeError11(error, code) {
 }
 
 // src/conversations/hermes-session-sync.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID11 } from "crypto";
 import { readdir as readdir7, readFile as readFile11, stat as stat12 } from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 
 // src/conversations/delivery-import.ts
 import { lstat as lstat2, readFile as readFile10, readdir as readdir6, stat as stat11 } from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 var MAX_IMPORTED_BLOB_BYTES = 100 * 1024 * 1024;
 var MAX_MEDIA_IMPORT_FAILURES = 20;
 var MAX_DELIVERY_FILES = 50;
@@ -20065,16 +20763,16 @@ var SUPPORTED_DELIVERY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".m4a"
 ]);
 function resolveDeliveryStagingTarget(paths, stagingDir) {
-  const resolvedDir = path19.resolve(stagingDir);
-  const relative = path19.relative(path19.resolve(paths.conversationsDir), resolvedDir);
-  if (!relative || relative.startsWith("..") || path19.isAbsolute(relative)) {
+  const resolvedDir = path20.resolve(stagingDir);
+  const relative = path20.relative(path20.resolve(paths.conversationsDir), resolvedDir);
+  if (!relative || relative.startsWith("..") || path20.isAbsolute(relative)) {
     throw new LinkHttpError(
       400,
       "delivery_staging_invalid",
       "delivery staging directory must be inside Hermes Link conversations"
     );
   }
-  const segments = relative.split(path19.sep);
+  const segments = relative.split(path20.sep);
   if (segments.length !== 3 || segments[1] !== DELIVERY_STAGING_SEGMENT || !segments[0] || !segments[2]) {
     throw new LinkHttpError(
       400,
@@ -20110,7 +20808,7 @@ async function collectStagedDeliveryReferences(stagingDir) {
   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 = path19.join(stagingDir, entry.name);
+    const sourcePath = path20.join(stagingDir, entry.name);
     const mime = inferMimeType(sourcePath);
     return {
       path: sourcePath,
@@ -20296,7 +20994,7 @@ async function writeBlobFromFile(deps, conversationId, source) {
   }
   return deps.writeBlob(conversationId, {
     bytes: await readFile10(sourcePath),
-    filename: path19.basename(sourcePath),
+    filename: path20.basename(sourcePath),
     mime: source.mime ?? inferMimeType(sourcePath)
   });
 }
@@ -20309,7 +21007,7 @@ function describeMediaImportFailure(reference, sourceKey, error) {
   };
 }
 function isSupportedDeliveryFilename(filename) {
-  return SUPPORTED_DELIVERY_EXTENSIONS.has(path19.extname(filename).toLowerCase());
+  return SUPPORTED_DELIVERY_EXTENSIONS.has(path20.extname(filename).toLowerCase());
 }
 function readString10(payload, key) {
   const value = payload[key];
@@ -20367,7 +21065,7 @@ async function syncHermesSessionsIntoConversations(paths, logger, options = {})
   const candidates = [];
   for (const profileName of profileNames) {
     const profileDir = resolveHermesProfileDir(profileName);
-    const dbPath = path20.join(profileDir, "state.db");
+    const dbPath = path21.join(profileDir, "state.db");
     const sessions = await listProfileSessions(dbPath).catch((error) => {
       result.errors.push({
         profile: profileName,
@@ -20483,7 +21181,7 @@ async function syncHermesCronSessionIntoConversations(paths, logger, input) {
   const knownHermesSessions = await readKnownHermesSessions(store);
   const profileName = input.profileName.trim() || DEFAULT_PROFILE_NAME;
   const profileDir = resolveHermesProfileDir(profileName);
-  const dbPath = path20.join(profileDir, "state.db");
+  const dbPath = path21.join(profileDir, "state.db");
   const sessions = await listProfileSessionsByIdPrefix(
     dbPath,
     `cron_${jobId}_`
@@ -20548,6 +21246,131 @@ async function syncHermesCronSessionIntoConversations(paths, logger, input) {
     reprojected: false
   };
 }
+async function syncHermesConversationMessages(paths, logger, input) {
+  const store = input.store ?? new ConversationStore(paths);
+  const manifest = await store.readActiveManifest(input.conversationId);
+  const snapshot = await store.readSnapshot(input.conversationId);
+  const targets = collectHermesSessionDeleteTargets(manifest, snapshot);
+  const result = {
+    conversation_id: input.conversationId,
+    hermes_session_ids: targets.map((target) => target.sessionId),
+    appended_count: 0,
+    changed: false,
+    errors: []
+  };
+  if (targets.length === 0) {
+    return result;
+  }
+  const candidates = await collectConversationSyncCandidates(targets);
+  const knownExactKeys = collectKnownHermesRowKeys(snapshot);
+  const representedMessages = collectRepresentedMessageSignatures(snapshot);
+  const projectedMessages = [];
+  const candidateProfiles = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    try {
+      const candidateMessages = await readHermesLineageMessages(candidate);
+      if (candidateMessages.length === 0) {
+        continue;
+      }
+      const profile = await resolveConversationProfileTarget(
+        paths,
+        candidate.profileName
+      );
+      candidateProfiles.set(conversationSyncCandidateKey(candidate), {
+        candidate,
+        profileUid: profile.profileUid,
+        profileName: profile.profileName
+      });
+      projectedMessages.push(
+        ...toLinkMessages({
+          conversationId: input.conversationId,
+          profileName: profile.profileName,
+          profileUid: profile.profileUid,
+          profileDisplayName: profile.profileDisplayName,
+          sessionId: candidate.session.id,
+          messages: candidateMessages
+        })
+      );
+    } catch (error) {
+      result.errors.push({
+        profile: candidate.profileName,
+        session_id: candidate.session.id,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const appendedMessages = [];
+  for (const message of projectedMessages.sort(compareLinkMessagesByCreatedAt)) {
+    const exactKeys = collectMessageHermesRowKeys(message);
+    if (exactKeys.length > 0 && exactKeys.every((key) => knownExactKeys.has(key))) {
+      consumeRepresentedMessageSignature(representedMessages, message);
+      continue;
+    }
+    if (consumeRepresentedMessageSignature(representedMessages, message)) {
+      exactKeys.forEach((key) => knownExactKeys.add(key));
+      continue;
+    }
+    appendedMessages.push(message);
+    exactKeys.forEach((key) => knownExactKeys.add(key));
+  }
+  if (appendedMessages.length === 0) {
+    return result;
+  }
+  await store.writeSnapshot(input.conversationId, {
+    ...snapshot,
+    messages: [...snapshot.messages, ...appendedMessages]
+  });
+  await hydrateImportedConversationMedia({
+    paths,
+    store,
+    logger,
+    conversationId: input.conversationId
+  });
+  const hydratedSnapshot = await store.readSnapshot(input.conversationId);
+  const appendedIds = new Set(appendedMessages.map((message) => message.id));
+  const hydratedAppendedMessages = hydratedSnapshot.messages.filter(
+    (message) => appendedIds.has(message.id)
+  );
+  let nextManifest = await store.readManifest(input.conversationId);
+  for (const profile of candidateProfiles.values()) {
+    nextManifest = mergeHermesLineageIntoManifest({
+      manifest: nextManifest,
+      candidate: profile.candidate,
+      snapshot: hydratedSnapshot,
+      profileUid: profile.profileUid,
+      profileName: profile.profileName,
+      updatedAt: isoFromHermesTime(profile.candidate.session.last_active) ?? nextManifest.updated_at
+    });
+  }
+  const stats = buildConversationStats(nextManifest, hydratedSnapshot);
+  nextManifest = {
+    ...nextManifest,
+    stats,
+    updated_at: latestTimestamp(
+      nextManifest.updated_at,
+      latestMessageTimestamp(hydratedAppendedMessages)
+    )
+  };
+  await store.writeManifest(nextManifest);
+  await upsertConversationStats(paths, toStatsIndexRecord(nextManifest, stats));
+  const appendEvent = input.appendEvent ?? ((conversationId, event) => store.appendEvent(conversationId, event));
+  let lastEventSeq;
+  for (const message of hydratedAppendedMessages) {
+    const event = await appendEvent(input.conversationId, {
+      type: "message.created",
+      message_id: message.id,
+      payload: { message, imported_from: "hermes" },
+      raw: message.raw
+    });
+    lastEventSeq = event.seq;
+  }
+  result.appended_count = hydratedAppendedMessages.length;
+  result.changed = hydratedAppendedMessages.length > 0;
+  if (lastEventSeq !== void 0) {
+    result.last_event_seq = lastEventSeq;
+  }
+  return result;
+}
 async function importHermesSession(input) {
   const { paths, store, logger, candidate } = input;
   const profile = await resolveConversationProfileTarget(
@@ -20759,6 +21582,143 @@ function findKnownConversationIdsForCandidate(known, candidate) {
   }
   return conversationIds;
 }
+async function collectConversationSyncCandidates(targets) {
+  const sessionIdsByProfile = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const profileName = target.profileName.trim() || DEFAULT_PROFILE_NAME;
+    const sessionId = target.sessionId.trim();
+    if (!sessionId) {
+      continue;
+    }
+    const current = sessionIdsByProfile.get(profileName) ?? /* @__PURE__ */ new Set();
+    current.add(sessionId);
+    sessionIdsByProfile.set(profileName, current);
+  }
+  const candidates = [];
+  const seenCandidates = /* @__PURE__ */ new Set();
+  for (const [profileName, targetSessionIds] of sessionIdsByProfile) {
+    const profileDir = resolveHermesProfileDir(profileName);
+    const dbPath = path21.join(profileDir, "state.db");
+    const coveredSessionIds = /* @__PURE__ */ new Set();
+    const sessions = await listProfileSessions(dbPath).catch(() => []);
+    for (const session of sessions) {
+      if (isDeletedSession(session) || isHiddenSession(session)) {
+        continue;
+      }
+      const candidate = {
+        profileName,
+        profileDir,
+        dbPath,
+        session
+      };
+      const candidateSessionIds = lineageSessionIds(candidate);
+      if (!candidateSessionIds.some(
+        (sessionId) => targetSessionIds.has(sessionId)
+      )) {
+        continue;
+      }
+      for (const sessionId of candidateSessionIds) {
+        if (targetSessionIds.has(sessionId)) {
+          coveredSessionIds.add(sessionId);
+        }
+      }
+      const key = conversationSyncCandidateKey(candidate);
+      if (!seenCandidates.has(key)) {
+        seenCandidates.add(key);
+        candidates.push(candidate);
+      }
+    }
+    for (const sessionId of targetSessionIds) {
+      if (coveredSessionIds.has(sessionId)) {
+        continue;
+      }
+      const candidate = {
+        profileName,
+        profileDir,
+        dbPath,
+        session: { id: sessionId }
+      };
+      const key = conversationSyncCandidateKey(candidate);
+      if (!seenCandidates.has(key)) {
+        seenCandidates.add(key);
+        candidates.push(candidate);
+      }
+    }
+  }
+  return candidates;
+}
+function conversationSyncCandidateKey(candidate) {
+  return `${candidate.profileName}\0${candidate.session.id}`;
+}
+function collectKnownHermesRowKeys(snapshot) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const message of snapshot.messages) {
+    collectMessageHermesRowKeys(message).forEach((key) => keys.add(key));
+  }
+  return keys;
+}
+function collectMessageHermesRowKeys(message) {
+  const keys = [];
+  readHermesRawMessageRows(message.raw).forEach((row, index) => {
+    keys.push(hermesRowKey(row, index));
+  });
+  const hermes = toRecord11(message.hermes);
+  const sessionId = readString11(hermes, "session_id") ?? "";
+  const messageIds = Array.isArray(hermes.message_ids) ? hermes.message_ids : hermes.message_id === void 0 || hermes.message_id === null ? [] : [hermes.message_id];
+  for (const messageId of messageIds) {
+    if (messageId === void 0 || messageId === null) {
+      continue;
+    }
+    keys.push(hermesMessageIdKey(sessionId, messageId));
+  }
+  return [...new Set(keys)];
+}
+function collectRepresentedMessageSignatures(snapshot) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const message of snapshot.messages) {
+    const signature = representedMessageSignature(message);
+    if (!signature) {
+      continue;
+    }
+    counts.set(signature, (counts.get(signature) ?? 0) + 1);
+  }
+  return counts;
+}
+function consumeRepresentedMessageSignature(counts, message) {
+  const signature = representedMessageSignature(message);
+  if (!signature) {
+    return false;
+  }
+  const count = counts.get(signature) ?? 0;
+  if (count <= 0) {
+    return false;
+  }
+  if (count === 1) {
+    counts.delete(signature);
+  } else {
+    counts.set(signature, count - 1);
+  }
+  return true;
+}
+function representedMessageSignature(message) {
+  const text = messageText(message);
+  if (!text) {
+    return null;
+  }
+  return `${message.role}:${hashText(text)}`;
+}
+function hashText(value) {
+  return createHash6("sha256").update(value).digest("hex");
+}
+function compareLinkMessagesByCreatedAt(left, right) {
+  return Date.parse(left.created_at) - Date.parse(right.created_at) || left.id.localeCompare(right.id);
+}
+function latestMessageTimestamp(messages2) {
+  return messages2.reduce(
+    (latest, message) => latestTimestamp(latest, message.updated_at || message.created_at),
+    messages2[0]?.updated_at ?? (/* @__PURE__ */ new Date()).toISOString()
+  );
+}
 function lineageSessionIds(candidate) {
   return normalizeSessionIds([
     candidate.session._lineage_root_id,
@@ -21048,9 +22008,12 @@ function appendHermesRowOnce(rows, seen, row) {
 }
 function hermesRowKey(row, fallbackIndex) {
   if (row.id !== void 0 && row.id !== null) {
-    return `id:${row.id}`;
+    return hermesMessageIdKey(readString11(row, "session_id") ?? "", row.id);
   }
-  return `fallback:${fallbackIndex}:${row.role ?? ""}:${row.timestamp ?? ""}:${normalizeContent2(row.content)}`;
+  return `fallback:${readString11(row, "session_id") ?? ""}:${fallbackIndex}:${row.role ?? ""}:${row.timestamp ?? ""}:${normalizeContent2(row.content)}`;
+}
+function hermesMessageIdKey(sessionId, messageId) {
+  return `id:${sessionId}:${String(messageId)}`;
 }
 function hasHermesToolMetadata(row) {
   return normalizeMessageRole(row.role) === "tool" || readHermesToolCalls(row).length > 0 || Boolean(readString11(row, "tool_call_id")) || Boolean(readString11(row, "tool_name"));
@@ -21794,8 +22757,8 @@ async function readJsonlMessages(profileName, sessionId) {
     return [];
   }
   const profileDir = resolveHermesProfileDir(profileName);
-  const sessionsDir = await readHermesSessionsDir(profileName).then((value) => value.sessionsDir).catch(() => path20.join(profileDir, "sessions"));
-  const transcriptPath = path20.join(sessionsDir, `${sessionId}.jsonl`);
+  const sessionsDir = await readHermesSessionsDir(profileName).then((value) => value.sessionsDir).catch(() => path21.join(profileDir, "sessions"));
+  const transcriptPath = path21.join(sessionsDir, `${sessionId}.jsonl`);
   const raw = await readFile11(transcriptPath, "utf8").catch((error) => {
     if (isNodeError13(error, "ENOENT")) {
       return "";
@@ -22103,13 +23066,13 @@ function toRecord11(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function isDeletedSession(session) {
-  return readBoolean(session.deleted) || readBoolean(session.is_deleted) || Boolean(readString11(session, "deleted_at")) || ["deleted", "removed"].includes(readString11(session, "status") ?? "");
+  return readBoolean2(session.deleted) || readBoolean2(session.is_deleted) || Boolean(readString11(session, "deleted_at")) || ["deleted", "removed"].includes(readString11(session, "status") ?? "");
 }
 function isHiddenSession(session) {
   const source = readString11(session, "source")?.toLowerCase();
   const status = readString11(session, "status")?.toLowerCase();
   const visibility = readString11(session, "visibility")?.toLowerCase();
-  return Boolean(source && HIDDEN_SESSION_SOURCES.has(source)) || readBoolean(session.hidden) || readBoolean(session.archived) || Boolean(readString11(session, "archived_at")) || status === "hidden" || status === "archived" || visibility === "hidden" || visibility === "hide";
+  return Boolean(source && HIDDEN_SESSION_SOURCES.has(source)) || readBoolean2(session.hidden) || readBoolean2(session.archived) || Boolean(readString11(session, "archived_at")) || status === "hidden" || status === "archived" || visibility === "hidden" || visibility === "hide";
 }
 function readTableColumns2(db, tableName) {
   try {
@@ -22150,7 +23113,7 @@ function readString11(payload, key) {
 function readNumber3(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
-function readBoolean(value) {
+function readBoolean2(value) {
   if (value === true || value === 1) {
     return true;
   }
@@ -22165,7 +23128,7 @@ function isNodeError13(error, code) {
 
 // src/conversations/delivery-context.ts
 import { copyFile, mkdir as mkdir11, stat as stat13 } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 var ACTIVE_CONTEXTS = /* @__PURE__ */ new Map();
 var CONTEXT_TTL_MS = 2 * 60 * 60 * 1e3;
 var MAX_DELIVERY_TOOL_FILES = 50;
@@ -22237,10 +23200,10 @@ function findDeliveryContext(input) {
   );
 }
 async function copyFilesIntoDeliveryContext(paths, context, files) {
-  const stagingDir = path21.resolve(context.stagingDir);
-  const conversationsRoot = path21.resolve(paths.conversationsDir);
-  const relative = path21.relative(conversationsRoot, stagingDir);
-  if (!relative || relative.startsWith("..") || path21.isAbsolute(relative)) {
+  const stagingDir = path22.resolve(context.stagingDir);
+  const conversationsRoot = path22.resolve(paths.conversationsDir);
+  const relative = path22.relative(conversationsRoot, stagingDir);
+  if (!relative || relative.startsWith("..") || path22.isAbsolute(relative)) {
     throw new LinkHttpError(
       400,
       "delivery_staging_invalid",
@@ -22251,13 +23214,13 @@ async function copyFilesIntoDeliveryContext(paths, context, files) {
   const result = { staged: [], skipped: [] };
   const usedNames = /* @__PURE__ */ new Set();
   for (const [index, file] of files.slice(0, MAX_DELIVERY_TOOL_FILES).entries()) {
-    const sourcePath = path21.resolve(file.path);
+    const sourcePath = path22.resolve(file.path);
     let baseName = sanitizeFilename(
-      file.caption || path21.basename(sourcePath),
+      file.caption || path22.basename(sourcePath),
       `attachment-${index + 1}`
     );
-    const sourceExtension = path21.extname(sourcePath);
-    if (!path21.extname(baseName) && sourceExtension) {
+    const sourceExtension = path22.extname(sourcePath);
+    if (!path22.extname(baseName) && sourceExtension) {
       baseName = `${baseName}${sourceExtension}`;
     }
     const filename = uniqueStagingFilename(
@@ -22284,7 +23247,7 @@ async function copyFilesIntoDeliveryContext(paths, context, files) {
       });
       continue;
     }
-    const targetPath = path21.join(stagingDir, filename);
+    const targetPath = path22.join(stagingDir, filename);
     await copyFile(sourcePath, targetPath);
     result.staged.push({
       source_path: sourcePath,
@@ -22327,7 +23290,7 @@ function normalizeDeliveryFileInputs(value) {
   });
 }
 function uniqueStagingFilename(filename, usedNames) {
-  const extension = path21.extname(filename);
+  const extension = path22.extname(filename);
   const stem = filename.slice(0, filename.length - extension.length);
   let candidate = filename;
   let suffix = 2;
@@ -22368,7 +23331,7 @@ function isNodeError14(error, code) {
 }
 
 // src/conversations/run-lifecycle.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { readdir as readdir9 } from "fs/promises";
 
 // src/hermes/api-server.ts
@@ -22818,9 +23781,9 @@ function parseHermesApiCapabilities(payload) {
   const runStop = isRecord2(endpoints.run_stop) ? endpoints.run_stop : {};
   return {
     source: "reported",
-    authRequired: readBoolean2(auth, "required"),
-    responsesStreaming: readBoolean2(features, "responses_streaming"),
-    runStopPath: readBoolean2(features, "run_stop") === false ? null : readString13(runStop, "path"),
+    authRequired: readBoolean3(auth, "required"),
+    responsesStreaming: readBoolean3(features, "responses_streaming"),
+    runStopPath: readBoolean3(features, "run_stop") === false ? null : readString13(runStop, "path"),
     sessionContinuityHeader: readString13(
       features,
       "session_continuity_header"
@@ -22828,10 +23791,10 @@ function parseHermesApiCapabilities(payload) {
     sessionKeyHeader: readString13(features, "session_key_header")
   };
 }
-async function callHermesApi(path37, init, options) {
+async function callHermesApi(path38, init, options) {
   const method = init.method ?? "GET";
   const startedAt = Date.now();
-  void options.logger?.debug("hermes_api_request_started", { method, path: path37 });
+  void options.logger?.debug("hermes_api_request_started", { method, path: path38 });
   const availability = await ensureHermesApiServerAvailable({
     fetchImpl: options.fetchImpl,
     logger: options.logger,
@@ -22840,7 +23803,7 @@ async function callHermesApi(path37, init, options) {
   });
   let config = availability.configResult.apiServer;
   const fetcher = options.fetchImpl ?? fetch;
-  const request = () => fetchHermesApi(fetcher, config, path37, init, options);
+  const request = () => fetchHermesApi(fetcher, config, path38, init, options);
   let response;
   try {
     response = await request();
@@ -22848,7 +23811,7 @@ async function callHermesApi(path37, init, options) {
     logHermesApiError(
       options.logger,
       method,
-      path37,
+      path38,
       options.profileName,
       startedAt,
       error
@@ -22859,7 +23822,7 @@ async function callHermesApi(path37, init, options) {
     logHermesApiResponse(
       options.logger,
       method,
-      path37,
+      path38,
       options.profileName,
       startedAt,
       response
@@ -22868,7 +23831,7 @@ async function callHermesApi(path37, init, options) {
   }
   void options.logger?.warn("hermes_api_request_retrying_after_401", {
     method,
-    path: path37,
+    path: path38,
     profile: options.profileName ?? "default",
     port: config.port ?? null,
     duration_ms: Date.now() - startedAt
@@ -22887,7 +23850,7 @@ async function callHermesApi(path37, init, options) {
     logHermesApiError(
       options.logger,
       method,
-      path37,
+      path38,
       options.profileName,
       startedAt,
       error
@@ -22897,7 +23860,7 @@ async function callHermesApi(path37, init, options) {
   logHermesApiResponse(
     options.logger,
     method,
-    path37,
+    path38,
     options.profileName,
     startedAt,
     response
@@ -22907,7 +23870,7 @@ async function callHermesApi(path37, init, options) {
   }
   void options.logger?.warn("hermes_api_request_repairing_after_401", {
     method,
-    path: path37,
+    path: path38,
     profile: options.profileName ?? "default",
     port: config.port ?? null,
     duration_ms: Date.now() - startedAt
@@ -22928,7 +23891,7 @@ async function callHermesApi(path37, init, options) {
     logHermesApiError(
       options.logger,
       method,
-      path37,
+      path38,
       options.profileName,
       startedAt,
       error
@@ -22938,21 +23901,21 @@ async function callHermesApi(path37, init, options) {
   logHermesApiResponse(
     options.logger,
     method,
-    path37,
+    path38,
     options.profileName,
     startedAt,
     response
   );
   return response;
 }
-async function fetchHermesApi(fetcher, config, path37, init, options) {
+async function fetchHermesApi(fetcher, config, path38, 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}${path37}`, {
+  return await fetcher(`http://127.0.0.1:${config.port}${path38}`, {
     ...init,
     headers
   }).catch((error) => {
@@ -22961,10 +23924,10 @@ async function fetchHermesApi(fetcher, config, path37, init, options) {
     }
     void options.logger?.warn("hermes_api_server_connect_failed", {
       method: String(init.method ?? "GET").toUpperCase(),
-      path: path37,
+      path: path38,
       profile: options.profileName ?? "default",
       port: config.port ?? null,
-      url: `http://127.0.0.1:${config.port}${path37}`,
+      url: `http://127.0.0.1:${config.port}${path38}`,
       error: error instanceof Error ? error.message : String(error)
     });
     throw new LinkHttpError(
@@ -22974,10 +23937,10 @@ async function fetchHermesApi(fetcher, config, path37, init, options) {
     );
   });
 }
-function logHermesApiResponse(logger, method, path37, profileName, startedAt, response) {
+function logHermesApiResponse(logger, method, path38, profileName, startedAt, response) {
   const fields = {
     method,
-    path: path37,
+    path: path38,
     profile: profileName ?? "default",
     status: response.status,
     duration_ms: Date.now() - startedAt
@@ -22998,10 +23961,10 @@ async function logHermesApiFailureResponse(logger, fields, response) {
     ...upstreamError ? { upstream_error: upstreamError } : {}
   });
 }
-function logHermesApiError(logger, method, path37, profileName, startedAt, error) {
+function logHermesApiError(logger, method, path38, profileName, startedAt, error) {
   void logger?.warn("hermes_api_request_failed", {
     method,
-    path: path37,
+    path: path38,
     profile: profileName ?? "default",
     duration_ms: Date.now() - startedAt,
     ...error instanceof LinkHttpError ? { status: error.status, code: error.code } : {},
@@ -23062,18 +24025,18 @@ function readString13(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function readBoolean2(payload, key) {
+function readBoolean3(payload, key) {
   const value = payload[key];
   return typeof value === "boolean" ? value : null;
 }
 
 // src/hermes/stt.ts
-import { execFile as execFile3 } from "child_process";
+import { execFile as execFile4 } from "child_process";
 import { access as access2, readFile as readFile12, stat as stat14 } from "fs/promises";
 import os6 from "os";
-import path22 from "path";
-import { promisify as promisify3 } from "util";
-var execFileAsync3 = promisify3(execFile3);
+import path23 from "path";
+import { promisify as promisify4 } from "util";
+var execFileAsync4 = promisify4(execFile4);
 var STT_RESULT_PREFIX = "__HERMES_LINK_STT__";
 var STT_TIMEOUT_MS = 18e4;
 var STT_MAX_BUFFER_BYTES = 2 * 1024 * 1024;
@@ -23106,7 +24069,7 @@ async function transcribeAudioWithHermesProfile(input) {
   let stdout = "";
   let stderr = "";
   try {
-    const output = await execFileAsync3(
+    const output = await execFileAsync4(
       python.command,
       [...python.args, "-c", script, input.audioPath],
       {
@@ -23166,7 +24129,7 @@ async function buildHermesSttEnv(profileName, hermesSourceRoot) {
   };
   const sourceRoot = hermesSourceRoot ?? await findDevHermesAgentSource();
   if (sourceRoot) {
-    env.PYTHONPATH = [sourceRoot, env.PYTHONPATH].filter(Boolean).join(path22.delimiter);
+    env.PYTHONPATH = [sourceRoot, env.PYTHONPATH].filter(Boolean).join(path23.delimiter);
   }
   return env;
 }
@@ -23261,14 +24224,14 @@ async function resolveHermesPythonRuntime() {
   };
 }
 async function resolveExecutablePath(command) {
-  if (path22.isAbsolute(command)) {
+  if (path23.isAbsolute(command)) {
     return await isExecutableFile2(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(path22.delimiter)) {
+  for (const dir of pathEnv.split(path23.delimiter)) {
     for (const extension of extensions) {
-      const candidate = path22.join(dir, `${command}${extension}`);
+      const candidate = path23.join(dir, `${command}${extension}`);
       if (await isExecutableFile2(candidate)) {
         return candidate;
       }
@@ -23290,11 +24253,11 @@ async function isExecutableFile2(filePath) {
 }
 async function findHermesVenvPython(sourceRoot) {
   const candidates = process.platform === "win32" ? [
-    path22.join(sourceRoot, "venv", "Scripts", "python.exe"),
-    path22.join(sourceRoot, ".venv", "Scripts", "python.exe")
+    path23.join(sourceRoot, "venv", "Scripts", "python.exe"),
+    path23.join(sourceRoot, ".venv", "Scripts", "python.exe")
   ] : [
-    path22.join(sourceRoot, "venv", "bin", "python"),
-    path22.join(sourceRoot, ".venv", "bin", "python")
+    path23.join(sourceRoot, "venv", "bin", "python"),
+    path23.join(sourceRoot, ".venv", "bin", "python")
   ];
   for (const candidate of candidates) {
     if (await isExecutableFile2(candidate)) {
@@ -23323,8 +24286,8 @@ function shebangToPythonCommand(shebang) {
 }
 async function findDevHermesAgentSource() {
   const candidates = [
-    path22.resolve(process.cwd(), "reference/hermes-agent"),
-    path22.resolve(process.cwd(), "../../reference/hermes-agent")
+    path23.resolve(process.cwd(), "reference/hermes-agent"),
+    path23.resolve(process.cwd(), "../../reference/hermes-agent")
   ];
   for (const candidate of candidates) {
     if (await isHermesAgentSourceRoot(candidate)) {
@@ -23340,7 +24303,7 @@ async function readHermesLauncherTarget(filePath) {
       line
     );
     const rawTarget = quoted?.groups?.target ?? /^\s*exec\s+(?<target>\S+)\s+(?:"\$@"|'\$@')/.exec(line)?.groups?.target;
-    if (!rawTarget || !path22.isAbsolute(rawTarget)) {
+    if (!rawTarget || !path23.isAbsolute(rawTarget)) {
       continue;
     }
     if (await isExecutableFile2(rawTarget)) {
@@ -23370,12 +24333,12 @@ async function resolveHermesEntrypointRuntime(entrypointPath) {
   return null;
 }
 async function findHermesSourceRoot(executablePath) {
-  let cursor = path22.dirname(path22.resolve(executablePath));
+  let cursor = path23.dirname(path23.resolve(executablePath));
   for (let index = 0; index < 6; index += 1) {
     if (await isHermesAgentSourceRoot(cursor)) {
       return cursor;
     }
-    const parent = path22.dirname(cursor);
+    const parent = path23.dirname(cursor);
     if (parent === cursor) {
       break;
     }
@@ -23386,14 +24349,14 @@ async function findHermesSourceRoot(executablePath) {
 function hermesSourceRootCandidates() {
   const candidates = [
     process.env.HERMES_PYTHON_SRC_ROOT?.trim(),
-    path22.join(os6.homedir(), ".hermes", "hermes-agent"),
+    path23.join(os6.homedir(), ".hermes", "hermes-agent"),
     "/usr/local/lib/hermes-agent",
     "/opt/hermes"
   ].filter((candidate) => Boolean(candidate));
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA?.trim();
     if (localAppData) {
-      candidates.unshift(path22.join(localAppData, "hermes", "hermes-agent"));
+      candidates.unshift(path23.join(localAppData, "hermes", "hermes-agent"));
     }
   }
   return candidates;
@@ -23403,7 +24366,7 @@ async function findExplicitHermesSourceRoot() {
   return explicit && await isHermesAgentSourceRoot(explicit) ? explicit : null;
 }
 async function isHermesAgentSourceRoot(candidate) {
-  return await isDirectory(candidate) && await isDirectory(path22.join(candidate, "tools")) && await isDirectory(path22.join(candidate, "hermes_cli"));
+  return await isDirectory(candidate) && await isDirectory(path23.join(candidate, "tools")) && await isDirectory(path23.join(candidate, "hermes_cli"));
 }
 async function isDirectory(candidate) {
   return stat14(candidate).then((info) => info.isDirectory()).catch(() => false);
@@ -23415,15 +24378,15 @@ function compactProcessOutput(value) {
 
 // src/hermes/usage-probe.ts
 import { open as open3, readFile as readFile14, rm as rm6, stat as stat16 } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 import YAML3 from "yaml";
 
 // src/hermes/profiles.ts
-import { execFile as execFile4 } from "child_process";
+import { execFile as execFile5 } from "child_process";
 import { readdir as readdir8, readFile as readFile13, rename as rename3, stat as stat15 } from "fs/promises";
-import path23 from "path";
-import { setTimeout as delay4 } from "timers/promises";
-import { promisify as promisify4 } from "util";
+import path24 from "path";
+import { setTimeout as delay5 } from "timers/promises";
+import { promisify as promisify5 } from "util";
 import YAML2 from "yaml";
 var DEFAULT_PROFILE = "default";
 var PROFILE_NAME_PATTERN5 = /^[a-zA-Z0-9._-]{1,64}$/;
@@ -23431,7 +24394,7 @@ var PROFILE_DELETE_TIMEOUT_MS = 3e4;
 var PROFILE_GATEWAY_STOP_TIMEOUT_MS = 3e3;
 var PROFILE_DELETE_STABLE_ABSENCE_MS = 1200;
 var PROFILE_DELETE_VERIFY_INTERVAL_MS = 150;
-var execFileAsync4 = promisify4(execFile4);
+var execFileAsync5 = promisify5(execFile5);
 async function listHermesProfiles(paths = resolveRuntimePaths()) {
   const profiles = /* @__PURE__ */ new Map();
   if (await hasDefaultProfileConfigSource()) {
@@ -23564,7 +24527,7 @@ async function readHermesProfileCapabilities(name) {
   return {
     defaultModel: listedModels?.defaultModel ?? null,
     modelCount: listedModels?.models.length ?? 0,
-    skillCount: await countSkills(path23.join(profileDir, "skills")).catch(
+    skillCount: await countSkills(path24.join(profileDir, "skills")).catch(
       () => 0
     ),
     toolCount: await countConfiguredTools(name).catch(() => 0)
@@ -23625,11 +24588,11 @@ async function hasDefaultProfileConfigSource() {
   if (!profileStat?.isDirectory()) {
     return false;
   }
-  return await pathExists(resolveHermesConfigPath(DEFAULT_PROFILE)) || await pathExists(path23.join(profilePath, ".env"));
+  return await pathExists(resolveHermesConfigPath(DEFAULT_PROFILE)) || await pathExists(path24.join(profilePath, ".env"));
 }
 async function deleteHermesProfileWithCli(name) {
   try {
-    await execFileAsync4(resolveHermesBin(), ["profile", "delete", name, "--yes"], {
+    await execFileAsync5(resolveHermesBin(), ["profile", "delete", name, "--yes"], {
       timeout: PROFILE_DELETE_TIMEOUT_MS,
       windowsHide: true
     });
@@ -23688,7 +24651,7 @@ async function findHermesGatewayProcessIdsForProfile(name) {
     return [];
   }
   try {
-    const output = await execFileAsync4("ps", ["-axo", "pid=,command="], {
+    const output = await execFileAsync5("ps", ["-axo", "pid=,command="], {
       timeout: 3e3,
       windowsHide: true
     });
@@ -23728,7 +24691,7 @@ async function waitForProcessesToExit(pids, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   let remaining = pids.filter(isProcessRunning);
   while (remaining.length > 0 && Date.now() < deadline) {
-    await delay4(100);
+    await delay5(100);
     remaining = remaining.filter(isProcessRunning);
   }
   return remaining;
@@ -23747,7 +24710,7 @@ async function waitForProfilePathToRemainAbsent(profilePath) {
     if (await pathExists(profilePath)) {
       return false;
     }
-    await delay4(PROFILE_DELETE_VERIFY_INTERVAL_MS);
+    await delay5(PROFILE_DELETE_VERIFY_INTERVAL_MS);
   }
   return !await pathExists(profilePath);
 }
@@ -23795,7 +24758,7 @@ async function countSkills(root) {
   );
   let count = 0;
   for (const entry of entries) {
-    const entryPath = path23.join(root, entry.name);
+    const entryPath = path24.join(root, entry.name);
     if (entry.name === ".git" || entry.name === ".hub") {
       continue;
     }
@@ -23888,7 +24851,7 @@ async function ensureHermesUsageProbeForProfile(profileName, options = {}) {
   const normalizedProfile = normalizeProfileName6(profileName);
   const profilePath = resolveHermesProfileDir(normalizedProfile);
   const configPath = resolveHermesConfigPath(normalizedProfile);
-  const pluginPath = path24.join(
+  const pluginPath = path25.join(
     profilePath,
     "plugins",
     HERMES_USAGE_PROBE_PLUGIN_KEY
@@ -23914,7 +24877,7 @@ async function ensureHermesUsageProbeForProfile(profileName, options = {}) {
     return { ...base(), skipped: true };
   }
   try {
-    await ensureDirectoryWithInheritedMetadata(path24.dirname(eventsPath), 448);
+    await ensureDirectoryWithInheritedMetadata(path25.dirname(eventsPath), 448);
     const state = await readUsageProbeState(paths);
     const pluginState = state.profiles[normalizedProfile];
     const currentConfig = await readUsageProbeConfigStatus({
@@ -24047,7 +25010,7 @@ async function findHermesUsageProbeEventForRun(input) {
   return aggregateUsageProbeEvents(events.sort(compareUsageProbeEventsByTime));
 }
 function resolveUsageProbeEventsPath(paths = resolveRuntimePaths(), profileName = "default") {
-  return path24.join(
+  return path25.join(
     paths.homeDir,
     USAGE_PROBE_DIR,
     safeProfileSegment(profileName),
@@ -24071,8 +25034,8 @@ function summarizeUsageProbeEnsure(result) {
   };
 }
 async function writeUsageProbePlugin(input) {
-  const manifestPath = path24.join(input.pluginPath, "plugin.yaml");
-  const initPath = path24.join(input.pluginPath, "__init__.py");
+  const manifestPath = path25.join(input.pluginPath, "plugin.yaml");
+  const initPath = path25.join(input.pluginPath, "__init__.py");
   const manifest = usageProbeManifest();
   const source = usageProbePythonSource(
     input.profileName,
@@ -24419,9 +25382,9 @@ async function disableUsageProbeAfterActivationFailure(input) {
   });
 }
 async function cleanupLegacyUsageProbePlugin(profilePath) {
-  const legacyPath = path24.join(profilePath, "plugins", LEGACY_PLUGIN_KEY);
+  const legacyPath = path25.join(profilePath, "plugins", LEGACY_PLUGIN_KEY);
   const [manifest, init] = await Promise.all([
-    readFile14(path24.join(legacyPath, "plugin.yaml"), "utf8").catch(
+    readFile14(path25.join(legacyPath, "plugin.yaml"), "utf8").catch(
       (error) => {
         if (isNodeError16(error, "ENOENT")) {
           return null;
@@ -24429,7 +25392,7 @@ async function cleanupLegacyUsageProbePlugin(profilePath) {
         throw error;
       }
     ),
-    readFile14(path24.join(legacyPath, "__init__.py"), "utf8").catch(
+    readFile14(path25.join(legacyPath, "__init__.py"), "utf8").catch(
       (error) => {
         if (isNodeError16(error, "ENOENT")) {
           return null;
@@ -24478,7 +25441,7 @@ async function rememberUsageProbeState(paths, profileName, patch) {
   }));
 }
 function usageProbeStatePath(paths) {
-  return path24.join(paths.homeDir, USAGE_PROBE_DIR, USAGE_PROBE_STATE_FILE);
+  return path25.join(paths.homeDir, USAGE_PROBE_DIR, USAGE_PROBE_STATE_FILE);
 }
 async function readHermesConfigDocument2(configPath, language) {
   const existingRaw = await readFile14(configPath, "utf8").catch(
@@ -25046,7 +26009,7 @@ function toRecord14(value) {
 
 // src/conversations/run-transcript-enrichment.ts
 import { readFile as readFile15, stat as stat17 } from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 var MESSAGE_COLUMNS2 = [
   "id",
   "session_id",
@@ -25122,8 +26085,8 @@ async function readRunFinalAssistantText(input) {
 }
 async function readHermesTranscriptRows(profileName, sessionId) {
   const profileDir = resolveHermesProfileDir(profileName);
-  const dbPath = path25.join(profileDir, "state.db");
-  const sessionsDir = await readHermesSessionsDir(profileName).then((value) => value.sessionsDir).catch(() => path25.join(profileDir, "sessions"));
+  const dbPath = path26.join(profileDir, "state.db");
+  const sessionsDir = await readHermesSessionsDir(profileName).then((value) => value.sessionsDir).catch(() => path26.join(profileDir, "sessions"));
   const [dbRows, jsonlRows] = await Promise.all([
     readStateDbMessages2(dbPath, sessionId),
     readJsonlMessages2(sessionsDir, sessionId)
@@ -25186,7 +26149,7 @@ async function readJsonlMessages2(sessionsDir, sessionId) {
   if (!/^[A-Za-z0-9._:-]{1,160}$/u.test(sessionId)) {
     return [];
   }
-  const transcriptPath = path25.join(sessionsDir, `${sessionId}.jsonl`);
+  const transcriptPath = path26.join(sessionsDir, `${sessionId}.jsonl`);
   const raw = await readFile15(transcriptPath, "utf8").catch((error) => {
     if (isNodeError17(error, "ENOENT")) {
       return "";
@@ -25438,7 +26401,7 @@ function isNodeError17(error, code) {
 }
 
 // src/conversations/run-tool-event-ids.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 var RunToolEventIdCoalescer = class {
   scope;
   ordinal = 0;
@@ -25453,7 +26416,7 @@ var RunToolEventIdCoalescer = class {
     if (!type || hasStableToolEventId(event.payload)) {
       return event;
     }
-    const toolKey = normalizeToolKey(readToolName(event.payload));
+    const toolKey = normalizeToolKey(readToolName2(event.payload));
     if (type === "tool.started") {
       return withGeneratedToolEventId(
         event,
@@ -25544,7 +26507,7 @@ function hasStableToolEventId(payload) {
     readString17(payload, "tool_call_id") ?? readString17(payload, "toolCallId") ?? readString17(payload, "tool_id") ?? readString17(payload, "call_id") ?? readString17(payload, "id") ?? readString17(tool, "id") ?? readString17(call, "id") ?? readString17(fn, "id")
   );
 }
-function readToolName(payload) {
+function readToolName2(payload) {
   const tool = toRecord16(payload.tool);
   const call = toRecord16(payload.tool_call ?? payload.toolCall);
   const fn = toRecord16(call.function ?? payload.function);
@@ -25603,7 +26566,7 @@ function stableStringify2(value) {
   }
 }
 function hashStableValue(value) {
-  return createHash6("sha256").update(value).digest("hex").slice(0, 16);
+  return createHash7("sha256").update(value).digest("hex").slice(0, 16);
 }
 function readString17(payload, key) {
   const value = payload[key];
@@ -26014,6 +26977,96 @@ function toRecord17(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 
+// src/conversations/goal-lifecycle-marker.ts
+var GOAL_LIFECYCLE_MARKER_FORMAT = "hermes-link-lifecycle-marker";
+var GOAL_COMPLETION_MARKER_KIND = "goal_completion";
+function createGoalCompletionMarker(input) {
+  const text = goalCompletionMarkerText(input.goal, input.language);
+  return {
+    id: goalCompletionMarkerId(input.runId),
+    schema_version: 1,
+    conversation_id: input.conversationId,
+    role: "system",
+    status: "completed",
+    run_id: input.runId,
+    created_at: input.completedAt,
+    updated_at: input.completedAt,
+    sender: {
+      id: "hermes_link",
+      type: "system",
+      display_name: "Hermes Link"
+    },
+    parts: [{ type: "text", text }],
+    attachments: [],
+    raw: {
+      format: GOAL_LIFECYCLE_MARKER_FORMAT,
+      payload: {
+        kind: GOAL_COMPLETION_MARKER_KIND,
+        status: "completed",
+        completed_at: input.completedAt,
+        run_id: input.runId,
+        text,
+        ...Number.isFinite(input.goal.turns_used) ? { turns_used: input.goal.turns_used } : {},
+        ...Number.isFinite(input.goal.max_turns) ? { max_turns: input.goal.max_turns } : {},
+        ...input.goal.usage ? { usage: input.goal.usage } : {}
+      }
+    }
+  };
+}
+function goalCompletionMarkerText(goal, language) {
+  const parts = [localizedText2(language, "\u76EE\u6807\u5DF2\u5B8C\u6210", "Goal completed")];
+  const turns = goalTurnsLabel(goal, language);
+  if (turns) {
+    parts.push(turns);
+  }
+  const totalTokens = finiteNonNegativeNumber(goal.usage?.total_tokens);
+  if (totalTokens !== void 0) {
+    parts.push(`${formatCompactNumber(totalTokens)} tokens`);
+  }
+  return parts.join(" ");
+}
+function goalCompletionMarkerId(runId) {
+  const safeRunId = runId.trim().replace(/[^a-zA-Z0-9_:-]/gu, "_");
+  return `msg_goal_completed_${safeRunId || "run"}`;
+}
+function goalTurnsLabel(goal, language) {
+  const turnsUsed = finiteNonNegativeNumber(goal.turns_used);
+  const maxTurns = finiteNonNegativeNumber(goal.max_turns);
+  if (turnsUsed !== void 0 && maxTurns !== void 0) {
+    return localizedText2(
+      language,
+      `${turnsUsed}/${maxTurns} \u8F6E`,
+      `${turnsUsed}/${maxTurns} turns`
+    );
+  }
+  if (turnsUsed !== void 0) {
+    return localizedText2(language, `${turnsUsed} \u8F6E`, `${turnsUsed} turns`);
+  }
+  return null;
+}
+function finiteNonNegativeNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return void 0;
+  }
+  return Math.floor(value);
+}
+function formatCompactNumber(value) {
+  if (value >= 1e6) {
+    return `${trimTrailingDecimal(value / 1e6)}m`;
+  }
+  if (value >= 1e3) {
+    return `${trimTrailingDecimal(value / 1e3)}k`;
+  }
+  return value.toLocaleString("en-US");
+}
+function trimTrailingDecimal(value) {
+  const rounded = Math.round(value * 10) / 10;
+  return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+}
+function localizedText2(language, zh, en) {
+  return language === "en" ? en : zh;
+}
+
 // src/conversations/run-lifecycle.ts
 var RUN_STATUS_RECOVERY_TIMEOUT_MS = 10 * 60 * 1e3;
 var RUN_STATUS_RECOVERY_INITIAL_DELAY_MS = 500;
@@ -26030,7 +27083,7 @@ var ConversationRunLifecycle = class {
     const snapshot = await this.deps.readSnapshot(conversationId);
     const run = snapshot.runs.find((item) => item.id === runId);
     if (!run || run.status !== "running") {
-      return;
+      return { shouldDrainQueue: true };
     }
     const controller = new AbortController();
     this.deps.activeRunControllers.set(runId, { conversationId, controller });
@@ -26384,7 +27437,7 @@ var ConversationRunLifecycle = class {
           return null;
         });
         if (!response) {
-          return;
+          return { shouldDrainQueue: true };
         }
         await this.consumeHermesEventStream({
           backend,
@@ -26406,7 +27459,15 @@ var ConversationRunLifecycle = class {
             reason: "cancelled by app"
           })
         );
-        return;
+        return { shouldDrainQueue: true };
+      }
+      if (isTuiGatewaySessionBusyError(error)) {
+        await this.markRunBlockedByTuiGatewayBusy({
+          conversationId,
+          runId,
+          error
+        });
+        return { shouldDrainQueue: false };
       }
       throw error;
     } finally {
@@ -26415,6 +27476,148 @@ var ConversationRunLifecycle = class {
       }
       unregisterDeliveryContext(runId);
     }
+    return { shouldDrainQueue: true };
+  }
+  async markRunBlockedByTuiGatewayBusy(input) {
+    const details = input.error instanceof TuiGatewaySessionBusyError ? input.error.details : void 0;
+    const snapshot = await this.deps.readSnapshot(input.conversationId);
+    const run = snapshot.runs.find((item) => item.id === input.runId);
+    if (!run) {
+      return;
+    }
+    const liveSession = await readTuiGatewayLiveSession({
+      profileName: run.profile,
+      runtimeSessionId: details?.runtimeSessionId ?? run.hermes_rpc_session_id,
+      storedSessionId: details?.storedSessionId ?? run.hermes_session_id,
+      logger: this.deps.logger,
+      paths: this.deps.paths
+    }).catch((error) => {
+      void this.deps.logger.debug("tui_gateway_busy_live_probe_failed", {
+        conversation_id: input.conversationId,
+        run_id: input.runId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    });
+    await this.markRunBlockedByTuiGatewayBusyLocked({
+      conversationId: input.conversationId,
+      runId: input.runId,
+      error: input.error,
+      liveSession,
+      runtimeSessionId: liveSession?.runtimeSessionId ?? details?.runtimeSessionId ?? run.hermes_rpc_session_id,
+      storedSessionId: liveSession?.storedSessionId ?? details?.storedSessionId ?? run.hermes_session_id,
+      method: details?.method
+    });
+    await this.deps.syncConversationMessages(input.conversationId).catch(
+      (error) => {
+        void this.deps.logger.warn("tui_gateway_busy_message_sync_failed", {
+          conversation_id: input.conversationId,
+          run_id: input.runId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    );
+  }
+  async markRunBlockedByTuiGatewayBusyLocked(input) {
+    await this.deps.withConversationLock(input.conversationId, async () => {
+      const snapshot = await this.deps.readSnapshot(input.conversationId);
+      const run = snapshot.runs.find((item) => item.id === input.runId);
+      if (!run || run.status !== "running") {
+        return;
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const assistant = snapshot.messages.find(
+        (item) => item.id === run.assistant_message_id
+      );
+      const errorMessage5 = input.error instanceof Error ? input.error.message : String(input.error);
+      run.hermes_backend = "tui_gateway";
+      run.hermes_rpc_session_id = input.runtimeSessionId;
+      if (input.storedSessionId) {
+        run.hermes_session_id = input.storedSessionId;
+      }
+      run.error_detail = "tui_gateway_session_busy";
+      run.error_message = errorMessage5;
+      if (assistant) {
+        assistant.status = "streaming";
+        assistant.updated_at = now;
+        assistant.hermes = {
+          ...assistant.hermes ?? {},
+          upstream_busy: true,
+          upstream_busy_at: now,
+          upstream_busy_message: errorMessage5,
+          ...input.method ? { upstream_busy_method: input.method } : {},
+          ...input.runtimeSessionId ? { upstream_runtime_session_id: input.runtimeSessionId } : {},
+          ...input.storedSessionId ? { upstream_session_id: input.storedSessionId } : {},
+          ...input.liveSession ? {
+            upstream_status: input.liveSession.status,
+            upstream_running: input.liveSession.running,
+            ...input.liveSession.preview ? { upstream_preview: input.liveSession.preview } : {}
+          } : {}
+        };
+      }
+      await this.deps.writeSnapshot(input.conversationId, snapshot);
+      if (input.storedSessionId) {
+        const manifest = await this.deps.readRunnableManifest(
+          input.conversationId
+        );
+        const nextManifest = addHermesSessionIdForProfileToManifest(
+          manifest,
+          input.storedSessionId,
+          run.profile
+        );
+        if (nextManifest !== manifest) {
+          await this.deps.writeManifest(nextManifest);
+        }
+      }
+      if (assistant) {
+        await this.deps.appendEvent(input.conversationId, {
+          type: "message.updated",
+          message_id: assistant.id,
+          run_id: run.id,
+          payload: {
+            message: assistant,
+            reason: "tui_gateway_session_busy",
+            upstream_busy: true,
+            ...input.liveSession ? {
+              upstream_session: sanitizeLiveSessionForEvent(
+                input.liveSession
+              )
+            } : {}
+          }
+        });
+      }
+      const event = await this.deps.appendEvent(input.conversationId, {
+        type: "run.upstream_busy",
+        message_id: assistant?.id,
+        run_id: run.id,
+        payload: {
+          run,
+          reason: "tui_gateway_session_busy",
+          error: errorMessage5,
+          ...input.method ? { method: input.method } : {},
+          ...input.liveSession ? {
+            upstream_session: sanitizeLiveSessionForEvent(
+              input.liveSession
+            )
+          } : {
+            upstream_session: {
+              ...input.runtimeSessionId ? { id: input.runtimeSessionId } : {},
+              ...input.storedSessionId ? { session_key: input.storedSessionId } : {}
+            }
+          }
+        }
+      });
+      await this.deps.persistConversationStats(input.conversationId, snapshot);
+      void this.deps.logger.warn("conversation_run_upstream_busy", {
+        conversation_id: input.conversationId,
+        run_id: input.runId,
+        event_seq: event.seq,
+        runtime_session_id: input.runtimeSessionId ?? null,
+        stored_session_id: input.storedSessionId ?? null,
+        upstream_status: input.liveSession?.status ?? null,
+        method: input.method ?? null
+      });
+    });
   }
   async ensureUsageProbeBeforeRun(input) {
     if (!shouldUseHermesUsageProbe(input.backend)) {
@@ -26640,6 +27843,9 @@ var ConversationRunLifecycle = class {
         await this.cancelRunAfterAbort(input.conversationId, input.runId);
         return;
       }
+      if (isTuiGatewaySessionBusyError(error)) {
+        throw error;
+      }
       streamError = error;
       await this.deps.logger.warn("tui_gateway_event_stream_interrupted", {
         backend: input.backend,
@@ -27957,6 +29163,13 @@ ${details.join("\n")}` : localizedEmptyHermesResponseMessage(language);
       completedAt,
       "expired"
     );
+    const goalCompletionMarker = run.mode === "goal" ? await this.appendGoalCompletionMarkerAfterAssistant({
+      conversationId,
+      snapshot,
+      run,
+      goal: goalUpdate ?? void 0,
+      completedAt
+    }) : null;
     await this.deps.writeSnapshot(conversationId, snapshot);
     if (goalUpdate) {
       await this.deps.appendEvent(conversationId, {
@@ -27968,6 +29181,14 @@ ${details.join("\n")}` : localizedEmptyHermesResponseMessage(language);
         }
       });
     }
+    if (goalCompletionMarker) {
+      await this.deps.appendEvent(conversationId, {
+        type: "message.created",
+        message_id: goalCompletionMarker.id,
+        run_id: runId,
+        payload: { message: goalCompletionMarker }
+      });
+    }
     await this.appendExpiredApprovalEvents(
       conversationId,
       runId,
@@ -28008,6 +29229,24 @@ ${details.join("\n")}` : localizedEmptyHermesResponseMessage(language);
       occurredAt: completedAt
     });
   }
+  async appendGoalCompletionMarkerAfterAssistant(input) {
+    const goal = input.goal ?? (await this.deps.readRunnableManifest(input.conversationId)).command_state?.goal;
+    if (goal?.status !== "done") {
+      return null;
+    }
+    if (findGoalCompletionMarker(input.snapshot, input.run.id)) {
+      return null;
+    }
+    const marker = createGoalCompletionMarker({
+      conversationId: input.conversationId,
+      runId: input.run.id,
+      goal,
+      completedAt: input.completedAt,
+      language: input.run.language === "en" ? "en" : "zh-CN"
+    });
+    insertLifecycleMarkerAfterAssistant(input.snapshot, marker, input.run);
+    return marker;
+  }
   async persistGoalUsageFromRunLocked(conversationId, run) {
     const manifest = await this.deps.readRunnableManifest(conversationId);
     const previousGoal = manifest.command_state?.goal;
@@ -28391,7 +29630,7 @@ ${details.join("\n")}` : localizedEmptyHermesResponseMessage(language);
     if (raw.length <= 200) {
       return raw;
     }
-    return `hermespilot:${createHash7("sha256").update(raw).digest("hex")}`;
+    return `hermespilot:${createHash8("sha256").update(raw).digest("hex")}`;
   }
   async assistantMessageIdForRun(conversationId, runId) {
     const snapshot = await this.deps.readSnapshot(conversationId).catch(() => null);
@@ -28536,6 +29775,23 @@ function insertLifecycleMarkerBeforeAssistant(snapshot, marker, run) {
   }
   snapshot.messages.push(marker);
 }
+function insertLifecycleMarkerAfterAssistant(snapshot, marker, run) {
+  const existingIndex = snapshot.messages.findIndex(
+    (message) => message.id === marker.id
+  );
+  if (existingIndex >= 0) {
+    snapshot.messages[existingIndex] = marker;
+    return;
+  }
+  const assistantIndex = snapshot.messages.findIndex(
+    (message) => message.id === run.assistant_message_id
+  );
+  if (assistantIndex >= 0) {
+    snapshot.messages.splice(assistantIndex + 1, 0, marker);
+    return;
+  }
+  snapshot.messages.push(marker);
+}
 function timestampBeforeAssistantForRun(snapshot, run, fallback) {
   const user = snapshot.messages.find(
     (message) => message.id === run.trigger_message_id
@@ -28561,6 +29817,12 @@ function findContextCompressionMarker(snapshot, operationId) {
     return message.raw?.format === CONTEXT_COMPRESSION_MARKER_FORMAT && payload.kind === CONTEXT_COMPRESSION_MARKER_KIND && payload.operation_id === operationId;
   });
 }
+function findGoalCompletionMarker(snapshot, runId) {
+  return snapshot.messages.find((message) => {
+    const payload = toRecord18(message.raw?.payload);
+    return message.raw?.format === GOAL_LIFECYCLE_MARKER_FORMAT && payload.kind === GOAL_COMPLETION_MARKER_KIND && payload.run_id === runId;
+  });
+}
 function nextContextCompressionGeneration(snapshot) {
   let maxGeneration = 0;
   for (const message of snapshot.messages) {
@@ -29000,6 +30262,21 @@ function expirePendingMessageApprovals(message, resolvedAt) {
   }
   return expired;
 }
+function sanitizeLiveSessionForEvent(liveSession) {
+  return {
+    id: liveSession.runtimeSessionId,
+    session_key: liveSession.storedSessionId,
+    status: liveSession.status,
+    running: liveSession.running,
+    ...liveSession.current ? { current: true } : {},
+    ...liveSession.title ? { title: liveSession.title } : {},
+    ...liveSession.preview ? { preview: liveSession.preview } : {},
+    ...liveSession.model ? { model: liveSession.model } : {},
+    ...liveSession.lastActiveAt !== void 0 ? { last_active: liveSession.lastActiveAt } : {},
+    ...liveSession.startedAt !== void 0 ? { started_at: liveSession.startedAt } : {},
+    ...liveSession.inflight ? { inflight: liveSession.inflight } : {}
+  };
+}
 function previewText2(message) {
   if (!message) {
     return null;
@@ -29008,15 +30285,15 @@ function previewText2(message) {
   return text ? text.slice(0, 512) : null;
 }
 function runNotificationSourceEventId(conversationId, runId, eventKind) {
-  const digest = createHash7("sha256").update(`${conversationId}:${runId}:${eventKind}`).digest("hex").slice(0, 24);
+  const digest = createHash8("sha256").update(`${conversationId}:${runId}:${eventKind}`).digest("hex").slice(0, 24);
   return `${conversationId}:${eventKind}:${digest}`;
 }
 function approvalNotificationSourceEventId(conversationId, runId, approvalId) {
-  const digest = createHash7("sha256").update(`${conversationId}:${runId}:${approvalId}:approval_required`).digest("hex").slice(0, 24);
+  const digest = createHash8("sha256").update(`${conversationId}:${runId}:${approvalId}:approval_required`).digest("hex").slice(0, 24);
   return `${conversationId}:approval_required:${digest}`;
 }
 function inputRequestNotificationSourceEventId(conversationId, runId, inputRequestId) {
-  const digest = createHash7("sha256").update(`${conversationId}:${runId}:${inputRequestId}:input_required`).digest("hex").slice(0, 24);
+  const digest = createHash8("sha256").update(`${conversationId}:${runId}:${inputRequestId}:input_required`).digest("hex").slice(0, 24);
   return `${conversationId}:input_required:${digest}`;
 }
 async function closeSseIterator(iterator) {
@@ -29127,6 +30404,7 @@ var ConversationService = class {
       isConversationRunnable: (conversationId) => this.store.isConversationRunnable(conversationId),
       writeBlob: (conversationId, input) => this.maintenance.writeBlob(conversationId, input),
       syncCronDeliveries: () => this.syncCronDeliveries(),
+      syncConversationMessages: (conversationId) => this.syncHermesConversationMessages(conversationId),
       scheduleTitleRefresh: (conversationId) => this.metadata.scheduleGeneratedTitleRefresh(conversationId)
     });
     this.orchestration = new ConversationOrchestrationCoordinator({
@@ -29705,6 +30983,16 @@ var ConversationService = class {
       }
     }
   }
+  async syncHermesConversationMessages(conversationId) {
+    return this.withConversationLock(
+      conversationId,
+      () => syncHermesConversationMessages(this.paths, this.logger, {
+        conversationId,
+        store: this.store,
+        appendEvent: (targetConversationId, event) => this.appendEvent(targetConversationId, event)
+      })
+    );
+  }
   async deliverStagedFiles(stagingDir) {
     const target = resolveDeliveryStagingTarget(this.paths, stagingDir);
     return this.withConversationLock(target.conversationId, async () => {
@@ -29774,6 +31062,16 @@ var ConversationService = class {
     };
   }
   async getMessages(conversationId, options = {}) {
+    if (options.syncHermes === true && !options.beforeMessageId) {
+      await this.syncHermesConversationMessages(conversationId).catch(
+        (error) => {
+          void this.logger.warn("hermes_conversation_message_sync_failed", {
+            conversation_id: conversationId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      );
+    }
     return this.queries.getMessages(conversationId, options);
   }
   async setConversationModel(conversationId, input) {
@@ -30659,7 +31957,7 @@ var ConversationService = class {
     }
   }
   hermesArchiveStateSyncMarkerPath() {
-    return path26.join(this.paths.indexesDir, "hermes-archive-state-sync.json");
+    return path27.join(this.paths.indexesDir, "hermes-archive-state-sync.json");
   }
   prepareClearAllConversationPlan(targetStatus) {
     return this.maintenance.prepareClearAllConversationPlan(targetStatus);
@@ -30818,7 +32116,7 @@ function findApproval(snapshot, approvalId) {
   return null;
 }
 function cronNotificationSourceEventId(conversationId, jobId, outputPath, eventKind) {
-  const digest = createHash8("sha256").update(`${conversationId}:${jobId}:${outputPath}:${eventKind}`).digest("hex").slice(0, 24);
+  const digest = createHash9("sha256").update(`${conversationId}:${jobId}:${outputPath}:${eventKind}`).digest("hex").slice(0, 24);
   return `${conversationId}:${eventKind}:${digest}`;
 }
 function conversationHermesSessionIds(manifest) {
@@ -30896,6 +32194,7 @@ function buildLiveActivityEvent(input) {
     return null;
   }
   const language = run?.language === "en" ? "en" : "zh";
+  const todoProgress = liveActivityTodoProgressForEvent(input.event);
   const text = liveActivityTextForEvent({
     event: input.event,
     snapshot: input.snapshot,
@@ -30919,11 +32218,56 @@ function buildLiveActivityEvent(input) {
     statusLabel: text.statusLabel,
     progressText: text.progressText,
     detailText: text.detailText,
+    todoDoneCount: todoProgress?.doneCount,
+    todoTotalCount: todoProgress?.totalCount,
+    todoProgressText: todoProgress?.progressText,
     requiresUserAction: phase === "needs_input" || phase === "needs_approval",
     terminal: isLiveActivityTerminalEvent(phase, target.kind),
     occurredAt: input.event.created_at
   };
 }
+function liveActivityTodoProgressForEvent(event) {
+  if (event.type.toLowerCase() !== "tool.completed") {
+    return null;
+  }
+  const payload = readRecord2(event.payload);
+  const toolName = readToolName3(payload)?.toLowerCase();
+  if (toolName !== "todo") {
+    return null;
+  }
+  const todos = readTodoItems2(payload.todos) ?? readTodoItems2(readRecord2(payload.result).todos);
+  if (todos) {
+    const totalCount2 = todos.length;
+    const doneCount2 = todos.filter((item) => {
+      const status = readString20(item, "status")?.toLowerCase();
+      return status === "completed" || status === "cancelled" || status === "canceled";
+    }).length;
+    return {
+      doneCount: doneCount2,
+      totalCount: totalCount2,
+      progressText: totalCount2 > 0 ? `${doneCount2}/${totalCount2}` : void 0
+    };
+  }
+  const summary = readRecord2(payload.summary).total === void 0 ? readRecord2(readRecord2(payload.result).summary) : readRecord2(payload.summary);
+  const totalCount = readInteger4(summary, "total");
+  if (totalCount === null) {
+    return null;
+  }
+  const completedCount = readInteger4(summary, "completed") ?? 0;
+  const cancelledCount = readInteger4(summary, "cancelled") ?? readInteger4(summary, "canceled") ?? 0;
+  const doneCount = Math.min(totalCount, completedCount + cancelledCount);
+  return {
+    doneCount,
+    totalCount,
+    progressText: totalCount > 0 ? `${doneCount}/${totalCount}` : void 0
+  };
+}
+function readTodoItems2(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  return value.map((item) => readRecord2(item)).filter((item) => Object.keys(item).length > 0);
+}
 function liveActivityConversationTitle(manifest, event, phase, language) {
   if (phase === "goal_running" || phase === "goal_paused") {
     const goal = manifest.command_state?.goal;
@@ -31009,7 +32353,7 @@ function liveActivityPhaseForEvent(event, run, contextOperation) {
     return run?.mode === "goal" ? "goal_running" : "accepted";
   }
   if (type === "conversation.goal.updated") {
-    const goal = readRecord(event.payload).goal;
+    const goal = readRecord2(event.payload).goal;
     const status = readString20(goal, "status");
     return status === "paused" ? "goal_paused" : "goal_running";
   }
@@ -31055,7 +32399,7 @@ function liveActivityPhaseForEvent(event, run, contextOperation) {
   return null;
 }
 function liveActivityTextForEvent(input) {
-  const toolName = readToolName2(input.event.payload);
+  const toolName = readToolName3(input.event.payload);
   const assistantText = input.event.message_id ? input.snapshot.messages.find((message) => message.id === input.event.message_id) : null;
   const preview = input.event.type.toLowerCase() === "reasoning.available" ? liveActivityReasoningPreview(input.event.payload) : isLiveActivityTerminalEvent(input.phase, input.run?.kind === "compression" ? "context_compression" : "run") && assistantText ? notificationPreviewText(assistantText) : null;
   if (input.language === "en") {
@@ -31159,7 +32503,7 @@ function isLiveActivityTerminalEvent(phase, targetKind) {
   return targetKind === "context_compression" && (phase === "context_compressed" || phase === "context_compression_failed" || phase === "context_compression_timed_out");
 }
 function readContextCompressionOperation(payload) {
-  const operation = readRecord(payload).operation;
+  const operation = readRecord2(payload).operation;
   if (!operation || typeof operation !== "object") {
     return null;
   }
@@ -31176,23 +32520,31 @@ function readContextCompressionOperation(payload) {
     source: readString20(record, "source") === "manual" ? "manual" : "auto"
   };
 }
-function readToolName2(payload) {
-  const record = readRecord(payload);
-  return readString20(record, "tool_name") ?? readString20(record, "tool") ?? readString20(record, "name") ?? readString20(readRecord(record.tool), "name");
+function readToolName3(payload) {
+  const record = readRecord2(payload);
+  return readString20(record, "tool_name") ?? readString20(record, "tool") ?? readString20(record, "name") ?? readString20(readRecord2(record.tool), "name");
 }
-function readRecord(value) {
+function readRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 function readString20(value, key) {
-  const raw = readRecord(value)[key];
+  const raw = readRecord2(value)[key];
   return typeof raw === "string" && raw.trim() ? raw.trim() : null;
 }
+function readInteger4(value, key) {
+  const raw = readRecord2(value)[key];
+  const parsed = typeof raw === "number" ? raw : typeof raw === "string" && raw.trim() ? Number(raw) : Number.NaN;
+  if (!Number.isFinite(parsed)) {
+    return null;
+  }
+  return Math.max(0, Math.trunc(parsed));
+}
 function approvalRestartText(language, zh, en) {
   return language === "en" ? en : zh;
 }
 
 // src/security/devices.ts
-import { randomBytes as randomBytes3, randomUUID as randomUUID13, timingSafeEqual, createHash as createHash9 } from "crypto";
+import { randomBytes as randomBytes3, randomUUID as randomUUID13, timingSafeEqual, createHash as createHash10 } 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;
@@ -31488,7 +32840,7 @@ function randomToken(prefix) {
   return `${prefix}${randomBytes3(24).toString("base64url")}`;
 }
 function sha256(value) {
-  return createHash9("sha256").update(value).digest("hex");
+  return createHash10("sha256").update(value).digest("hex");
 }
 function safeEqual(left, right) {
   const leftBytes = Buffer.from(left);
@@ -31768,7 +33120,7 @@ function readPositiveInteger2(value) {
   }
   return void 0;
 }
-function readBoolean3(value) {
+function readBoolean4(value) {
   if (typeof value === "boolean") {
     return value;
   }
@@ -31806,7 +33158,7 @@ function readQueryString(value) {
   const trimmed = raw.trim();
   return trimmed ? trimmed : void 0;
 }
-function readInteger4(value) {
+function readInteger5(value) {
   const raw = Array.isArray(value) ? value[0] : value;
   if (typeof raw !== "string") {
     return void 0;
@@ -31889,7 +33241,7 @@ function readMessageAttachments(value) {
     }
     const kind = readAttachmentString(record.kind);
     const type = readAttachmentString(record.type);
-    const isVoiceNote = readBoolean3(record.is_voice_note) ?? readBoolean3(record.isVoiceNote);
+    const isVoiceNote = readBoolean4(record.is_voice_note) ?? readBoolean4(record.isVoiceNote);
     const durationMs = readPositiveInteger2(record.duration_ms) ?? readPositiveInteger2(record.durationMs);
     const waveform = readAttachmentWaveform2(
       record.waveform ?? record.waveform_samples ?? record.waveformSamples
@@ -32183,7 +33535,8 @@ function registerConversationRoutes(router, options) {
     ctx.set("cache-control", "no-store");
     const result = await conversations.getMessages(ctx.params.conversationId, {
       limit: readLimit(ctx.query.limit),
-      beforeMessageId: readQueryString(ctx.query.before_message_id) ?? readQueryString(ctx.query.before)
+      beforeMessageId: readQueryString(ctx.query.before_message_id) ?? readQueryString(ctx.query.before),
+      syncHermes: readConversationMessagesSyncHermes(ctx.query)
     });
     ctx.body = {
       ok: true,
@@ -32770,6 +34123,13 @@ function registerConversationRoutes(router, options) {
     }
   );
 }
+function readConversationMessagesSyncHermes(query) {
+  const explicit = readBoolean4(query.sync_hermes) ?? readBoolean4(query.syncHermes);
+  if (explicit !== void 0) {
+    return explicit;
+  }
+  return readQueryString(query.sync)?.toLowerCase() === "hermes";
+}
 async function prepareConversationListRead(conversations, logger, auth, options = {}) {
   if (options.syncHermesSessions) {
     await conversations.syncHermesSessions().catch((error) => {
@@ -32799,7 +34159,7 @@ function readConversationListCursor(query) {
 }
 function readConversationListForce(query) {
   const raw = Array.isArray(query.force) ? query.force[0] : query.force;
-  return readBoolean3(raw) === true;
+  return readBoolean4(raw) === true;
 }
 function readConversationWorkspaceFilter(query) {
   const workspace = readQueryString(query.workspace) ?? readQueryString(query.workspace_id);
@@ -32905,7 +34265,7 @@ function toConversationSummary(value) {
   return candidate;
 }
 function resolveConversationEventCursor(input) {
-  const queryAfter = readInteger4(input.queryAfter) ?? 0;
+  const queryAfter = readInteger5(input.queryAfter) ?? 0;
   const headerAfter = readNonNegativeIntegerHeader(input.lastEventIdHeader) ?? 0;
   return Math.max(queryAfter, headerAfter);
 }
@@ -33051,11 +34411,11 @@ function isSseRequestContext(ctx) {
   }
   return isSseRequestPath(ctx.path) || isActiveSseSocket(ctx.req.socket);
 }
-function isSseRequestPath(path37) {
-  if (!path37) {
+function isSseRequestPath(path38) {
+  if (!path38) {
     return false;
   }
-  return path37 === "/api/v1/conversations/events" || path37 === "/api/v1/profile-creation/events" || path37 === "/api/v1/hermes/update/events" || path37 === "/api/v1/link/update/events" || /^\/api\/v1\/conversations\/[^/]+\/events$/u.test(path37) || /^\/api\/v1\/runs\/[^/]+\/events$/u.test(path37);
+  return path38 === "/api/v1/conversations/events" || path38 === "/api/v1/profile-creation/events" || path38 === "/api/v1/hermes/update/events" || path38 === "/api/v1/link/update/events" || /^\/api\/v1\/conversations\/[^/]+\/events$/u.test(path38) || /^\/api\/v1\/runs\/[^/]+\/events$/u.test(path38);
 }
 function isExpectedClientDisconnectError2(error, options = {}) {
   if (!(error instanceof Error)) {
@@ -33419,7 +34779,7 @@ function readCronJobUpdateInput(body) {
   if (repeat !== void 0) {
     input.repeat = repeat;
   }
-  const enabled = readBoolean3(body.enabled);
+  const enabled = readBoolean4(body.enabled);
   if (enabled !== void 0) {
     input.enabled = enabled;
   }
@@ -33489,12 +34849,12 @@ function assertCronJobId(jobId) {
 }
 
 // src/http/routes/model-configs.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 
 // src/model-catalog/catalog.ts
 import { randomInt } from "crypto";
 import { mkdir as mkdir12 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import { fileURLToPath } from "url";
 var MODEL_CATALOG_CACHE_VERSION = 1;
 var MODEL_CATALOG_FETCH_TIMEOUT_MS = 1e4;
@@ -33698,7 +35058,7 @@ async function readCachedCatalogFile(paths) {
   return cached;
 }
 async function writeCachedCatalog(paths, value) {
-  await mkdir12(path27.dirname(modelCatalogCachePath(paths)), {
+  await mkdir12(path28.dirname(modelCatalogCachePath(paths)), {
     recursive: true,
     mode: 448
   });
@@ -33714,7 +35074,7 @@ async function readFallbackCatalog() {
   throw new Error("model capability fallback catalog was not found");
 }
 function modelCatalogCachePath(paths) {
-  return path27.join(paths.homeDir, "model-capabilities", "catalog-cache.json");
+  return path28.join(paths.homeDir, "model-capabilities", "catalog-cache.json");
 }
 function normalizeModelCapabilityCatalog(value) {
   if (!value || typeof value !== "object") {
@@ -34718,7 +36078,7 @@ function modelProviderIdFromParts(input) {
     input.keyEnv ?? "",
     input.authType ?? ""
   ].join("");
-  return `mp_${createHash10("sha256").update(identity).digest("hex").slice(0, 18)}`;
+  return `mp_${createHash11("sha256").update(identity).digest("hex").slice(0, 18)}`;
 }
 function mergeCredentialState(left, right) {
   if (left === "configured" || right === "configured") {
@@ -35017,7 +36377,7 @@ function readModelConfigInput(body) {
       body.context_length ?? body.contextLength
     ),
     keyEnv: readString21(body, "key_env") ?? readString21(body, "keyEnv") ?? void 0,
-    setDefault: readBoolean3(body.set_default ?? body.setDefault),
+    setDefault: readBoolean4(body.set_default ?? body.setDefault),
     reasoningEffort: readString21(body, "reasoning_effort") ?? readString21(body, "reasoningEffort") ?? void 0,
     reasoningSupportPolicy: readString21(body, "reasoning_support_policy") ?? readString21(body, "reasoningSupportPolicy") ?? readString21(body, "reasoning_support") ?? readString21(body, "reasoningSupport") ?? void 0,
     supportsVision: readNullableBoolean2(
@@ -35086,14 +36446,14 @@ function readModelConfigImportInput(body) {
     provider: readString21(body, "provider") ?? readString21(body, "provider_key") ?? readString21(body, "providerKey") ?? void 0,
     baseUrl: readString21(body, "base_url") ?? readString21(body, "baseUrl") ?? void 0,
     apiMode: readString21(body, "api_mode") ?? readString21(body, "apiMode") ?? void 0,
-    setDefault: readBoolean3(body.set_default ?? body.setDefault)
+    setDefault: readBoolean4(body.set_default ?? body.setDefault)
   };
 }
 function shouldReloadGatewayAfterModelConfigChange(body, options = {}) {
-  if (readBoolean3(body.skip_gateway_reload ?? body.skipGatewayReload) === true) {
+  if (readBoolean4(body.skip_gateway_reload ?? body.skipGatewayReload) === true) {
     return false;
   }
-  if (readBoolean3(body.reload_gateway ?? body.reloadGateway) === true) {
+  if (readBoolean4(body.reload_gateway ?? body.reloadGateway) === true) {
     return true;
   }
   return options.defaultReload === true;
@@ -35193,7 +36553,7 @@ function errorMessage3(error) {
 
 // src/hermes/profile-identity.ts
 import { readFile as readFile16, stat as stat18 } from "fs/promises";
-import path28 from "path";
+import path29 from "path";
 var MAX_SOUL_MD_LENGTH = 2e4;
 async function readHermesProfileIdentity(profileName, paths) {
   await assertProfileExists3(profileName, paths);
@@ -35250,7 +36610,7 @@ async function assertProfileExists3(profileName, paths) {
   }
 }
 function resolveSoulPath(profileName) {
-  return path28.join(resolveHermesProfileDir(profileName), "SOUL.md");
+  return path29.join(resolveHermesProfileDir(profileName), "SOUL.md");
 }
 function isNodeError19(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
@@ -35266,13 +36626,13 @@ import {
   rm as rm7,
   stat as stat20
 } from "fs/promises";
-import path30 from "path";
+import path31 from "path";
 import YAML5 from "yaml";
 
 // src/hermes/link-skill.ts
 import { readFile as readFile17, stat as stat19 } from "fs/promises";
 import os7 from "os";
-import path29 from "path";
+import path30 from "path";
 import YAML4 from "yaml";
 var HERMES_LINK_SKILL_ROOT_DIR = "hermes-skills";
 var HERMES_LINK_SKILL_DIR = "hermes-link";
@@ -35329,13 +36689,20 @@ hermeslink logs -f
 hermeslink logs --all --level debug -f
 \`\`\`
 
-If the daemon appears stuck, suggest:
+If the daemon appears stuck, tell the user to run this in a separate computer
+terminal, outside of Hermes Agent:
 
 \`\`\`bash
 hermeslink restart
 \`\`\`
 
-Explain that restarting Hermes Link may briefly disconnect the mobile app.
+Never execute \`hermeslink restart\` yourself through Hermes Agent, terminal
+tools, shell tools, code execution, or any other in-session tool call.
+Restarting Hermes Link from inside the current HermesPilot App run can kill the
+Link/tui_gateway process that is carrying the response, interrupt the event
+stream, and leave the current run unrecoverable. If a restart is needed, only
+instruct the user to run it manually in their own terminal, then wait for the
+mobile app to reconnect.
 
 ## Troubleshooting Flow
 
@@ -35352,12 +36719,17 @@ Never reveal API keys, access tokens, refresh tokens, private keys, or full .env
 
 Do not recommend exposing port 52379 directly to the public internet without TLS, VPN, Tailscale, WireGuard, or another access-control layer.
 
+Do not execute Hermes Link service-control commands yourself from inside a
+Hermes Agent session. This includes \`hermeslink restart\`, \`hermeslink stop\`,
+\`hermeslink uninstall\`, and Link package update commands. Provide the command
+for the user to run in an external terminal instead.
+
 Do not modify Hermes profiles, delete user data, edit config files, or kill processes unless the user explicitly asks.
 `;
 async function ensureHermesLinkSkillInstalledForProfiles(options = {}) {
   const paths = options.paths ?? resolveRuntimePaths();
   const externalDir = resolveHermesLinkSkillExternalDir(paths);
-  const skillPath = path29.join(
+  const skillPath = path30.join(
     externalDir,
     HERMES_LINK_SKILL_DIR,
     HERMES_LINK_SKILL_FILE
@@ -35439,7 +36811,7 @@ function withDefaultProfilePlaceholder2(profiles) {
   ];
 }
 function resolveHermesLinkSkillExternalDir(paths = resolveRuntimePaths()) {
-  return path29.join(paths.homeDir, HERMES_LINK_SKILL_ROOT_DIR);
+  return path30.join(paths.homeDir, HERMES_LINK_SKILL_ROOT_DIR);
 }
 async function writeHermesLinkSkill(skillPath) {
   const existing = await readFile17(skillPath, "utf8").catch((error) => {
@@ -35534,11 +36906,11 @@ function appendExternalDir(current, externalDir, hermesHome) {
   const seen = new Set(
     entries.map((entry) => resolveExternalDirEntry(entry, hermesHome))
   );
-  const normalizedExternalDir = path29.resolve(externalDir);
+  const normalizedExternalDir = path30.resolve(externalDir);
   return seen.has(normalizedExternalDir) ? entries : [...entries, normalizedExternalDir];
 }
 function externalDirsInclude(current, externalDir, hermesHome) {
-  const normalizedExternalDir = path29.resolve(externalDir);
+  const normalizedExternalDir = path30.resolve(externalDir);
   return readExternalDirEntries(current).some(
     (entry) => resolveExternalDirEntry(entry, hermesHome) === normalizedExternalDir
   );
@@ -35549,14 +36921,14 @@ function readExternalDirEntries(value) {
 }
 function resolveExternalDirEntry(entry, hermesHome) {
   const expanded = expandHome(expandEnvVars(entry));
-  return path29.resolve(path29.isAbsolute(expanded) ? expanded : path29.join(hermesHome, expanded));
+  return path30.resolve(path30.isAbsolute(expanded) ? expanded : path30.join(hermesHome, expanded));
 }
 function expandHome(value) {
   if (value === "~") {
     return os7.homedir();
   }
-  if (value.startsWith(`~${path29.sep}`) || value.startsWith("~/")) {
-    return path29.join(os7.homedir(), value.slice(2));
+  if (value.startsWith(`~${path30.sep}`) || value.startsWith("~/")) {
+    return path30.join(os7.homedir(), value.slice(2));
   }
   return value;
 }
@@ -35795,7 +37167,7 @@ async function readHermesProfileCreationStatus(paths) {
   let state = await readJsonFile(
     profileCreationStatePath(paths)
   );
-  if (state?.state === "running" && !runningProfileCreation && !isRecentRunningState(state) && !isProcessAlive(state.pid)) {
+  if (state?.state === "running" && !runningProfileCreation && !isRecentRunningState(state) && !isProcessAlive2(state.pid)) {
     state = {
       ...state,
       state: "failed",
@@ -36108,7 +37480,7 @@ function collectEnvKeys(value, keys = /* @__PURE__ */ new Set()) {
   return keys;
 }
 async function writeEnvValues(profileName, values) {
-  const envPath = path30.join(resolveHermesProfileDir(profileName), ".env");
+  const envPath = path31.join(resolveHermesProfileDir(profileName), ".env");
   const existingRaw = await readFile18(envPath, "utf8").catch((error) => {
     if (isNodeError21(error, "ENOENT")) {
       return "";
@@ -36145,8 +37517,8 @@ async function writeEnvValues(profileName, values) {
   await atomicWriteFilePreservingMetadata(envPath, nextRaw);
 }
 async function copySkills(sourceProfile, targetProfile) {
-  const sourceSkills = path30.join(resolveHermesProfileDir(sourceProfile), "skills");
-  const targetSkills = path30.join(resolveHermesProfileDir(targetProfile), "skills");
+  const sourceSkills = path31.join(resolveHermesProfileDir(sourceProfile), "skills");
+  const targetSkills = path31.join(resolveHermesProfileDir(targetProfile), "skills");
   if (!await pathExists2(sourceSkills)) {
     return;
   }
@@ -36241,10 +37613,10 @@ async function readProfileCreationLogLines(paths) {
   );
 }
 function profileCreationStatePath(paths) {
-  return path30.join(paths.runDir, "profile-create-state.json");
+  return path31.join(paths.runDir, "profile-create-state.json");
 }
 function profileCreationLogPath(paths) {
-  return path30.join(paths.logsDir, PROFILE_CREATE_LOG_FILE);
+  return path31.join(paths.logsDir, PROFILE_CREATE_LOG_FILE);
 }
 async function clearProfileCreationLogFiles(paths) {
   const primary = profileCreationLogPath(paths);
@@ -36270,7 +37642,7 @@ function isRecentRunningState(state) {
   }
   return Date.now() - Date.parse(state.started_at) < 1e4;
 }
-function isProcessAlive(pid) {
+function isProcessAlive2(pid) {
   if (!pid || pid <= 0) {
     return false;
   }
@@ -36409,14 +37781,14 @@ function readProfilePermissionsInput(body) {
       containerDisk: readPositiveInteger2(
         terminal.container_disk ?? terminal.containerDisk
       ),
-      containerPersistent: readBoolean3(
+      containerPersistent: readBoolean4(
         terminal.container_persistent ?? terminal.containerPersistent
       )
     };
   }
   const sudo = readOptionalObject(body, "sudo");
   if (sudo) {
-    const clear = readBoolean3(sudo.clear ?? sudo.remove ?? sudo.delete);
+    const clear = readBoolean4(sudo.clear ?? sudo.remove ?? sudo.delete);
     const sudoInput = {
       password: readRawString2(sudo, "password") ?? readRawString2(sudo, "sudo_password") ?? readRawString2(sudo, "sudoPassword") ?? void 0,
       clear: clear === true ? true : void 0
@@ -36432,7 +37804,7 @@ function readProfilePermissionsInput(body) {
         toolsets.enabled_toolsets ?? toolsets.enabledToolsets ?? toolsets.enabled,
         "toolsets.enabled"
       ) ?? void 0,
-      mcpEnabled: readBoolean3(toolsets.mcp_enabled ?? toolsets.mcpEnabled)
+      mcpEnabled: readBoolean4(toolsets.mcp_enabled ?? toolsets.mcpEnabled)
     };
   }
   if (Object.keys(input).length === 0) {
@@ -36533,7 +37905,7 @@ import {
   readFile as readFile19,
   stat as stat21
 } from "fs/promises";
-import path31 from "path";
+import path32 from "path";
 import YAML6 from "yaml";
 var ENTRY_DELIMITER = "\n\xA7\n";
 var DEFAULT_MEMORY_LIMIT = 2200;
@@ -36864,7 +38236,7 @@ async function saveProviderSettings(profileName, provider, patch) {
     });
     await patchJsonProviderConfig(
       profileName,
-      path31.join("hindsight", "config.json"),
+      path32.join("hindsight", "config.json"),
       {
         mode: patch.mode,
         api_url: patch.apiUrl,
@@ -37067,7 +38439,7 @@ async function patchHermesMemoryLimits(profileName, patch) {
   await atomicWriteFilePreservingMetadata(configPath, document.toString());
 }
 function resolveMemoryDir(profileName) {
-  return path31.join(resolveHermesProfileDir(profileName), "memories");
+  return path32.join(resolveHermesProfileDir(profileName), "memories");
 }
 async function readMemoryStore(profileName, target, limits) {
   const filePath = memoryFilePath(profileName, target);
@@ -37128,7 +38500,7 @@ async function writeMemoryEntries(profileName, target, entries) {
   );
 }
 function memoryFilePath(profileName, target) {
-  return path31.join(
+  return path32.join(
     resolveMemoryDir(profileName),
     target === "user" ? "USER.md" : "MEMORY.md"
   );
@@ -37188,7 +38560,7 @@ async function readCustomProviderSetupSummary(profileName) {
     configurable: true,
     configured: true,
     configurationIssue: null,
-    providerConfigPath: path31.join(
+    providerConfigPath: path32.join(
       resolveHermesProfileDir(profileName),
       "<provider>.json"
     ),
@@ -37582,7 +38954,7 @@ async function readProviderSettings(profileName, provider) {
       stringSetting(
         "dbPath",
         "SQLite \u6570\u636E\u5E93\u8DEF\u5F84",
-        config.db_path ?? path31.join(resolveHermesProfileDir(profileName), "memory_store.db")
+        config.db_path ?? path32.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),
@@ -37618,7 +38990,7 @@ async function readProviderSettings(profileName, provider) {
       stringSetting(
         "workingDirectory",
         "\u5DE5\u4F5C\u76EE\u5F55",
-        path31.join(resolveHermesProfileDir(profileName), "byterover"),
+        path32.join(resolveHermesProfileDir(profileName), "byterover"),
         false
       )
     ];
@@ -37627,16 +38999,16 @@ async function readProviderSettings(profileName, provider) {
 }
 function memoryProviderConfigPath(profileName, provider) {
   if (provider === "honcho") {
-    return path31.join(resolveHermesProfileDir(profileName), "honcho.json");
+    return path32.join(resolveHermesProfileDir(profileName), "honcho.json");
   }
   if (provider === "mem0") {
-    return path31.join(resolveHermesProfileDir(profileName), "mem0.json");
+    return path32.join(resolveHermesProfileDir(profileName), "mem0.json");
   }
   if (provider === "supermemory") {
-    return path31.join(resolveHermesProfileDir(profileName), "supermemory.json");
+    return path32.join(resolveHermesProfileDir(profileName), "supermemory.json");
   }
   if (provider === "hindsight") {
-    return path31.join(
+    return path32.join(
       resolveHermesProfileDir(profileName),
       "hindsight",
       "config.json"
@@ -37645,13 +39017,13 @@ function memoryProviderConfigPath(profileName, provider) {
   return null;
 }
 function customProviderConfigPath(profileName, provider) {
-  return path31.join(
+  return path32.join(
     resolveHermesProfileDir(profileName),
     `${normalizeCustomProviderId(provider)}.json`
   );
 }
 function customProviderRegistryPath(profileName) {
-  return path31.join(
+  return path32.join(
     resolveHermesProfileDir(profileName),
     CUSTOM_PROVIDER_REGISTRY_FILE
   );
@@ -37703,7 +39075,7 @@ async function saveCustomProviderRegistryEntry(profileName, provider) {
   );
 }
 async function discoverUserMemoryProviderDescriptors(profileName) {
-  const pluginsDir = path31.join(resolveHermesProfileDir(profileName), "plugins");
+  const pluginsDir = path32.join(resolveHermesProfileDir(profileName), "plugins");
   const entries = await readdir10(pluginsDir, { withFileTypes: true }).catch(
     (error) => {
       if (isNodeError22(error, "ENOENT")) {
@@ -37723,7 +39095,7 @@ async function discoverUserMemoryProviderDescriptors(profileName) {
     } catch {
       continue;
     }
-    const providerDir = path31.join(pluginsDir, entry.name);
+    const providerDir = path32.join(pluginsDir, entry.name);
     if (!await isMemoryProviderPluginDir(providerDir)) {
       continue;
     }
@@ -37737,7 +39109,7 @@ async function discoverUserMemoryProviderDescriptors(profileName) {
   return descriptors;
 }
 async function isUserMemoryProviderInstalled(profileName, provider) {
-  const providerDir = path31.join(
+  const providerDir = path32.join(
     resolveHermesProfileDir(profileName),
     "plugins",
     normalizeCustomProviderId(provider)
@@ -37745,7 +39117,7 @@ async function isUserMemoryProviderInstalled(profileName, provider) {
   return isMemoryProviderPluginDir(providerDir);
 }
 async function isMemoryProviderPluginDir(providerDir) {
-  const source = await readFile19(path31.join(providerDir, "__init__.py"), "utf8").catch(
+  const source = await readFile19(path32.join(providerDir, "__init__.py"), "utf8").catch(
     (error) => {
       if (isNodeError22(error, "ENOENT")) {
         return "";
@@ -37757,7 +39129,7 @@ async function isMemoryProviderPluginDir(providerDir) {
   return sample.includes("register_memory_provider") || sample.includes("MemoryProvider");
 }
 async function readPluginMetadata(providerDir) {
-  const raw = await readFile19(path31.join(providerDir, "plugin.yaml"), "utf8").catch(
+  const raw = await readFile19(path32.join(providerDir, "plugin.yaml"), "utf8").catch(
     (error) => {
       if (isNodeError22(error, "ENOENT")) {
         return "";
@@ -37769,10 +39141,10 @@ async function readPluginMetadata(providerDir) {
 }
 async function resolveByteRoverCli() {
   const candidates = [
-    ...(process.env.PATH ?? "").split(path31.delimiter).filter(Boolean).map((dir) => path31.join(dir, "brv")),
-    path31.join(process.env.HOME ?? "", ".brv-cli", "bin", "brv"),
+    ...(process.env.PATH ?? "").split(path32.delimiter).filter(Boolean).map((dir) => path32.join(dir, "brv")),
+    path32.join(process.env.HOME ?? "", ".brv-cli", "bin", "brv"),
     "/usr/local/bin/brv",
-    path31.join(process.env.HOME ?? "", ".npm-global", "bin", "brv")
+    path32.join(process.env.HOME ?? "", ".npm-global", "bin", "brv")
   ].filter(Boolean);
   for (const candidate of candidates) {
     const found = await access3(candidate).then(() => true).catch(() => false);
@@ -37833,7 +39205,7 @@ async function patchHermesMemoryEnv(profileName, patch) {
   if (entries.length === 0) {
     return;
   }
-  const envPath = path31.join(resolveHermesProfileDir(profileName), ".env");
+  const envPath = path32.join(resolveHermesProfileDir(profileName), ".env");
   const existingRaw = await readFile19(envPath, "utf8").catch((error) => {
     if (isNodeError22(error, "ENOENT")) {
       return "";
@@ -38004,7 +39376,7 @@ async function readActiveMemoryProvider(profileName) {
   return provider;
 }
 async function patchJsonProviderConfig(profileName, relativePath, patch) {
-  const configPath = path31.join(
+  const configPath = path32.join(
     resolveHermesProfileDir(profileName),
     relativePath
   );
@@ -38033,7 +39405,7 @@ async function readJsonObject(filePath) {
   } catch {
     throw new HermesMemoryError(
       "memory_provider_config_invalid",
-      `${path31.basename(filePath)} \u4E0D\u662F\u6709\u6548\u7684 JSON \u914D\u7F6E\u6587\u4EF6\u3002`
+      `${path32.basename(filePath)} \u4E0D\u662F\u6709\u6548\u7684 JSON \u914D\u7F6E\u6587\u4EF6\u3002`
     );
   }
 }
@@ -38041,7 +39413,7 @@ function booleanSetting(key, label, value) {
   return {
     key,
     label,
-    value: readBoolean4(value) ?? false,
+    value: readBoolean5(value) ?? false,
     editable: true,
     kind: "boolean"
   };
@@ -38159,7 +39531,7 @@ function readPositiveInteger4(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 readBoolean4(value) {
+function readBoolean5(value) {
   if (typeof value === "boolean") {
     return value;
   }
@@ -38425,15 +39797,15 @@ function readMemorySettingsPatch(body, options = {}) {
   if (containerTag !== void 0) {
     input.containerTag = containerTag;
   }
-  const autoRecall = readBoolean3(body.auto_recall ?? body.autoRecall);
+  const autoRecall = readBoolean4(body.auto_recall ?? body.autoRecall);
   if (autoRecall !== void 0) {
     input.autoRecall = autoRecall;
   }
-  const autoCapture = readBoolean3(body.auto_capture ?? body.autoCapture);
+  const autoCapture = readBoolean4(body.auto_capture ?? body.autoCapture);
   if (autoCapture !== void 0) {
     input.autoCapture = autoCapture;
   }
-  const autoRetain = readBoolean3(body.auto_retain ?? body.autoRetain);
+  const autoRetain = readBoolean4(body.auto_retain ?? body.autoRetain);
   if (autoRetain !== void 0) {
     input.autoRetain = autoRetain;
   }
@@ -38503,7 +39875,7 @@ function readMemorySettingsPatch(body, options = {}) {
   if (writeFrequency) {
     input.writeFrequency = writeFrequency;
   }
-  const saveMessages = readBoolean3(body.save_messages ?? body.saveMessages);
+  const saveMessages = readBoolean4(body.save_messages ?? body.saveMessages);
   if (saveMessages !== void 0) {
     input.saveMessages = saveMessages;
   }
@@ -38543,7 +39915,7 @@ function readMemorySettingsPatch(body, options = {}) {
   if (agentId !== void 0) {
     input.agentId = agentId;
   }
-  const rerank = readBoolean3(body.rerank);
+  const rerank = readBoolean4(body.rerank);
   if (rerank !== void 0) {
     input.rerank = rerank;
   }
@@ -38567,7 +39939,7 @@ function readMemorySettingsPatch(body, options = {}) {
   if (dbPath !== void 0) {
     input.dbPath = dbPath;
   }
-  const autoExtract = readBoolean3(body.auto_extract ?? body.autoExtract);
+  const autoExtract = readBoolean4(body.auto_extract ?? body.autoExtract);
   if (autoExtract !== void 0) {
     input.autoExtract = autoExtract;
   }
@@ -38657,7 +40029,7 @@ function toMemoryHttpError(error) {
 
 // src/hermes/skills.ts
 import { readFile as readFile20, readdir as readdir11 } from "fs/promises";
-import path32 from "path";
+import path33 from "path";
 import YAML7 from "yaml";
 var HermesSkillNotFoundError = class extends Error {
   constructor(skillName) {
@@ -38671,7 +40043,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 = path32.join(profileDir, "skills");
+  const skillsRoot = path33.join(profileDir, "skills");
   const [skillFiles, disabled, provenance] = await Promise.all([
     findSkillFiles(skillsRoot),
     readDisabledSkillNames(resolveHermesConfigPath(profile.name)),
@@ -38762,7 +40134,7 @@ async function collectSkillFiles(directory, results) {
     if (EXCLUDED_SKILL_DIRS.has(entry.name)) {
       continue;
     }
-    const entryPath = path32.join(directory, entry.name);
+    const entryPath = path33.join(directory, entry.name);
     if (entry.isDirectory()) {
       await collectSkillFiles(entryPath, results);
       continue;
@@ -38784,10 +40156,10 @@ async function readSkillMetadata(input) {
   if (raw === null) {
     return null;
   }
-  const skillDir = path32.dirname(input.skillFile);
+  const skillDir = path33.dirname(input.skillFile);
   const { frontmatter, body } = parseSkillDocument(raw.slice(0, 4e3));
   const name = normalizeSkillName(
-    readString24(frontmatter.name) ?? path32.basename(skillDir)
+    readString24(frontmatter.name) ?? path33.basename(skillDir)
   );
   if (!name) {
     return null;
@@ -38806,7 +40178,7 @@ async function readSkillMetadata(input) {
     enabled: !input.disabled.has(name),
     source: provenance.source,
     trust: provenance.trust,
-    relativePath: path32.relative(input.skillsRoot, skillDir)
+    relativePath: path33.relative(input.skillsRoot, skillDir)
   };
 }
 function parseSkillDocument(raw) {
@@ -38827,8 +40199,8 @@ function parseSkillDocument(raw) {
   }
 }
 function categoryFromPath(skillsRoot, skillFile) {
-  const relative = path32.relative(skillsRoot, skillFile);
-  const parts = relative.split(path32.sep).filter(Boolean);
+  const relative = path33.relative(skillsRoot, skillFile);
+  const parts = relative.split(path33.sep).filter(Boolean);
   return parts.length >= 3 ? parts[0] : null;
 }
 function firstBodyDescription(body) {
@@ -38875,7 +40247,7 @@ async function readSkillProvenance(root) {
   return provenance;
 }
 async function readBundledSkillNames(root) {
-  const raw = await readFile20(path32.join(root, ".bundled_manifest"), "utf8").catch(
+  const raw = await readFile20(path33.join(root, ".bundled_manifest"), "utf8").catch(
     (error) => {
       if (isNodeError23(error, "ENOENT")) {
         return "";
@@ -38898,7 +40270,7 @@ async function readBundledSkillNames(root) {
   return names;
 }
 async function readHubInstalledSkills(root) {
-  const raw = await readFile20(path32.join(root, ".hub", "lock.json"), "utf8").catch(
+  const raw = await readFile20(path33.join(root, ".hub", "lock.json"), "utf8").catch(
     (error) => {
       if (isNodeError23(error, "ENOENT")) {
         return "";
@@ -39034,7 +40406,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 = readBoolean3(body.enabled);
+    const enabled = readBoolean4(body.enabled);
     if (enabled === void 0) {
       throw new LinkHttpError(
         400,
@@ -39472,7 +40844,7 @@ function registerStatisticsRoutes(router, options) {
     await authenticateRequest(ctx, paths);
     ctx.set("cache-control", "no-store");
     const usage = await readLinkUsageStatistics(paths, {
-      days: readInteger4(ctx.query.days),
+      days: readInteger5(ctx.query.days),
       from: readQueryString(ctx.query.from),
       to: readQueryString(ctx.query.to)
     });
@@ -39566,7 +40938,7 @@ function readModelList(payload) {
 import { EventEmitter as EventEmitter3 } from "events";
 import { spawn as spawn4 } from "child_process";
 import { mkdir as mkdir14, readFile as readFile21, rm as rm8 } from "fs/promises";
-import path33 from "path";
+import path34 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;
@@ -39713,7 +41085,7 @@ async function startHermesUpdate(options) {
 }
 async function readHermesUpdateStatus(paths) {
   let state = await readJsonFile(updateStatePath(paths));
-  if (state?.state === "running" && !runningUpdate && !isRecentRunningState2(state) && !isProcessAlive2(state.pid)) {
+  if (state?.state === "running" && !runningUpdate && !isRecentRunningState2(state) && !isProcessAlive3(state.pid)) {
     state = {
       ...state,
       state: "failed",
@@ -39844,13 +41216,13 @@ async function readUpdateLogLines(paths) {
   );
 }
 function releaseCachePath(paths) {
-  return path33.join(paths.indexesDir, "hermes-release-check.json");
+  return path34.join(paths.indexesDir, "hermes-release-check.json");
 }
 function updateStatePath(paths) {
-  return path33.join(paths.runDir, "hermes-update-state.json");
+  return path34.join(paths.runDir, "hermes-update-state.json");
 }
 function updateLogPath(paths) {
-  return path33.join(paths.logsDir, UPDATE_LOG_FILE);
+  return path34.join(paths.logsDir, UPDATE_LOG_FILE);
 }
 async function clearUpdateLogFiles(paths) {
   const primary = updateLogPath(paths);
@@ -39924,7 +41296,7 @@ async function readHermesReleaseCheckContext(paths) {
     releaseCheckUrl: url.toString()
   };
 }
-function isProcessAlive2(pid) {
+function isProcessAlive3(pid) {
   if (!pid || pid <= 0) {
     return false;
   }
@@ -39951,12 +41323,12 @@ function readString25(payload, key) {
 import { spawn as spawn6 } from "child_process";
 import { EventEmitter as EventEmitter4 } from "events";
 import { mkdir as mkdir17, readFile as readFile23, rm as rm11 } from "fs/promises";
-import path35 from "path";
+import path36 from "path";
 
 // src/daemon/process.ts
 import { spawn as spawn5 } from "child_process";
 import { mkdir as mkdir16, readFile as readFile22, rm as rm10, writeFile as writeFile4 } from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 
 // src/daemon/service.ts
 import { createServer } from "http";
@@ -40117,17 +41489,17 @@ async function fetchRelayStreamBatchPolicy(serverBaseUrl, options = {}) {
   }
 }
 function readRelayStreamBatchPolicy(input) {
-  const record = readRecord2(input);
-  const body = readRecord2(record?.policy) ?? readRecord2(record?.stream_batching) ?? record;
+  const record = readRecord3(input);
+  const body = readRecord3(record?.policy) ?? readRecord3(record?.stream_batching) ?? record;
   return normalizeRelayStreamBatchPolicy(body);
 }
 function normalizeRelayStreamBatchPolicy(input) {
-  const record = readRecord2(input);
+  const record = readRecord3(input);
   if (!record) {
     return null;
   }
-  const flushIntervalMs = readInteger5(record.flushIntervalMs ?? record.flush_interval_ms);
-  const flushBytes = readInteger5(record.flushBytes ?? record.flush_bytes);
+  const flushIntervalMs = readInteger6(record.flushIntervalMs ?? record.flush_interval_ms);
+  const flushBytes = readInteger6(record.flushBytes ?? record.flush_bytes);
   if (flushIntervalMs === null || flushBytes === null || flushIntervalMs < RELAY_STREAM_POLICY_CONSTRAINTS.flushIntervalMs.min || flushIntervalMs > RELAY_STREAM_POLICY_CONSTRAINTS.flushIntervalMs.max || flushBytes < RELAY_STREAM_POLICY_CONSTRAINTS.flushBytes.min || flushBytes > RELAY_STREAM_POLICY_CONSTRAINTS.flushBytes.max) {
     return null;
   }
@@ -40136,10 +41508,10 @@ function normalizeRelayStreamBatchPolicy(input) {
     flushBytes
   };
 }
-function readRecord2(value) {
+function readRecord3(value) {
   return value && typeof value === "object" ? value : null;
 }
-function readInteger5(value) {
+function readInteger6(value) {
   return typeof value === "number" && Number.isInteger(value) ? value : null;
 }
 
@@ -40173,12 +41545,12 @@ function connectRelayControl(options) {
     onUpdate: options.onStreamBatchPolicy
   };
   const startConnect = () => {
-    void waitForPersistedCooldown().then((delay5) => {
+    void waitForPersistedCooldown().then((delay6) => {
       if (closedByUser) {
         return;
       }
-      if (delay5 > 0) {
-        scheduleTimer(delay5, "cooldown", `Relay reconnect cooldown active for ${delay5}ms`);
+      if (delay6 > 0) {
+        scheduleTimer(delay6, "cooldown", `Relay reconnect cooldown active for ${delay6}ms`);
         return;
       }
       connect();
@@ -40316,8 +41688,8 @@ function connectRelayControl(options) {
     }
     if (recorded.cooldownUntilMs !== null) {
       reconnectAttempts = 0;
-      const delay6 = Math.max(0, recorded.cooldownUntilMs - Date.now());
-      scheduleTimer(delay6, "cooldown", `Relay reconnect storm guard active for ${delay6}ms`);
+      const delay7 = Math.max(0, recorded.cooldownUntilMs - Date.now());
+      scheduleTimer(delay7, "cooldown", `Relay reconnect storm guard active for ${delay7}ms`);
       return;
     }
     reconnectAttempts += 1;
@@ -40325,16 +41697,16 @@ function connectRelayControl(options) {
       baseMs: backoffBaseMs,
       maxMs: backoffMaxMs
     });
-    const delay5 = Math.max(backoffMs, relayRetryAfterMs ?? 0);
-    scheduleTimer(delay5, "retrying", `Retrying in ${delay5}ms`);
+    const delay6 = Math.max(backoffMs, relayRetryAfterMs ?? 0);
+    scheduleTimer(delay6, "retrying", `Retrying in ${delay6}ms`);
   }
   async function waitForPersistedCooldown() {
     return await readRelayCooldownDelayMs(paths).catch(() => 0);
   }
-  function scheduleTimer(delay5, state, message) {
+  function scheduleTimer(delay6, state, message) {
     clearRetryTimer();
     options.onStatus?.({ state, attempt: reconnectAttempts, message });
-    retryTimer = setTimeout(connect, delay5);
+    retryTimer = setTimeout(connect, delay6);
     retryTimer.unref?.();
   }
   function clearRetryTimer() {
@@ -40838,6 +42210,7 @@ async function observePublicRoute(options) {
       "content-type": "application/json",
       ...options.relayBootstrapToken ? { authorization: `Bearer ${options.relayBootstrapToken}` } : {}
     },
+    signal: options.signal,
     body: JSON.stringify({
       install_id: options.installId,
       link_id: options.linkId,
@@ -41123,7 +42496,8 @@ async function reportLinkStatusToServer(options = {}) {
     publicKeyPem: identity.public_key_pem,
     observePublicRoute: true,
     configuredLanHost: config.lanHost,
-    fetchImpl: options.fetchImpl
+    fetchImpl: options.fetchImpl,
+    signal: options.signal
   });
   const routes = await mergeLastReportedPublicRoutes(paths, discoveredRoutes);
   const systemInfo = readLinkSystemInfo();
@@ -41154,7 +42528,8 @@ async function reportLinkStatusToServer(options = {}) {
         ...payload,
         public_key_pem: identity.public_key_pem,
         signature
-      })
+      }),
+      signal: options.signal
     }
   );
   const body = await response.json().catch(() => null);
@@ -41202,19 +42577,28 @@ function startLanIpMonitor(options) {
   let running = false;
   let closed = false;
   let current = Promise.resolve();
+  let currentAbortController = null;
   const check = (context = {}) => {
     if (running || closed) {
       return current;
     }
     running = true;
+    const abortController = new AbortController();
+    currentAbortController = abortController;
     current = (async () => {
       try {
-        await checkLanIpChange(options, context);
+        await checkLanIpChange({ ...options, signal: abortController.signal }, context);
       } catch (error) {
+        if (closed && isAbortError3(error)) {
+          return;
+        }
         void options.logger.warn("lan_ip_monitor_failed", {
           error: error instanceof Error ? error.message : String(error)
         });
       } finally {
+        if (currentAbortController === abortController) {
+          currentAbortController = null;
+        }
         running = false;
       }
     })();
@@ -41233,6 +42617,7 @@ function startLanIpMonitor(options) {
     async close() {
       closed = true;
       clearInterval(timer);
+      currentAbortController?.abort();
       await current.catch(() => void 0);
     }
   };
@@ -41253,7 +42638,8 @@ async function checkLanIpChange(options, context = {}) {
     publicKeyPem: identity.public_key_pem,
     observePublicRoute: context.observePublicRoute === true,
     configuredLanHost: config.lanHost,
-    fetchImpl: options.fetchImpl
+    fetchImpl: options.fetchImpl,
+    signal: options.signal
   });
   const routes = await mergeLastReportedPublicRoutes(options.paths, discoveredRoutes);
   if (context.publishToRelay) {
@@ -41278,7 +42664,8 @@ async function checkLanIpChange(options, context = {}) {
     const result = await reportLinkStatusToServer({
       paths: options.paths,
       fetchImpl: options.fetchImpl,
-      routes
+      routes,
+      signal: options.signal
     });
     if (result) {
       options.onNetworkRoutes?.(routes);
@@ -41296,6 +42683,9 @@ async function checkLanIpChange(options, context = {}) {
     });
   }
 }
+function isAbortError3(error) {
+  return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
 
 // src/daemon/process-guard.ts
 var installed = false;
@@ -41609,6 +42999,22 @@ async function startLinkService(options = {}) {
     await logger.flush();
     throw error;
   }
+  const tuiGatewayCleanup = await cleanupRegisteredTuiGatewayProcesses({
+    paths,
+    logger
+  }).catch((error) => {
+    void logger.warn("tui_gateway_registry_startup_cleanup_failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  });
+  if (tuiGatewayCleanup) {
+    void logger.info("tui_gateway_registry_startup_cleanup_finished", {
+      stopped: tuiGatewayCleanup.stopped.length,
+      missing: tuiGatewayCleanup.missing.length,
+      skipped: tuiGatewayCleanup.skipped.length
+    });
+  }
   server.on("error", (error) => {
     void logger.error("service_error", {
       port: config.port,
@@ -41734,6 +43140,7 @@ async function startLinkService(options = {}) {
       }
       closed = true;
       relay?.close();
+      await closeTuiGatewayBackends({ paths, logger, cleanupRegistry: true });
       await closeServer(server);
       await Promise.all([
         scheduler.close(),
@@ -41949,7 +43356,7 @@ async function runDaemonSupervisor(paths = resolveRuntimePaths()) {
   await mkdir16(paths.logsDir, { recursive: true, mode: 448 });
   const log = createRotatingTextLogWriter({
     paths,
-    fileName: path34.basename(daemonLogFile(paths))
+    fileName: path35.basename(daemonLogFile(paths))
   });
   const scriptPath = currentCliScriptPath();
   const write = (chunk) => {
@@ -41968,7 +43375,7 @@ async function runDaemonSupervisor(paths = resolveRuntimePaths()) {
   let stopRequested = false;
   const forwardStop = () => {
     stopRequested = true;
-    if (child?.pid && isProcessAlive3(child.pid)) {
+    if (child?.pid && isProcessAlive4(child.pid)) {
       child.kill("SIGTERM");
     }
   };
@@ -42082,23 +43489,23 @@ async function stopDaemonProcess(paths = resolveRuntimePaths()) {
   }
   for (let index = 0; index < 20; index += 1) {
     await wait2(250);
-    if (!isProcessAlive3(status.pid)) {
+    if (!isProcessAlive4(status.pid)) {
       break;
     }
   }
-  if (isProcessAlive3(status.pid)) {
+  if (isProcessAlive4(status.pid)) {
     try {
       process.kill(status.pid, "SIGKILL");
     } catch {
     }
     for (let index = 0; index < 10; index += 1) {
       await wait2(250);
-      if (!isProcessAlive3(status.pid)) {
+      if (!isProcessAlive4(status.pid)) {
         break;
       }
     }
   }
-  if (!isProcessAlive3(status.pid) || !await pidBackedServiceIsReachable(paths)) {
+  if (!isProcessAlive4(status.pid) || !await pidBackedServiceIsReachable(paths)) {
     await rm10(pidFilePath(paths), { force: true }).catch(() => void 0);
   }
   return await getDaemonStatus(paths);
@@ -42106,7 +43513,7 @@ async function stopDaemonProcess(paths = resolveRuntimePaths()) {
 async function getDaemonStatus(paths = resolveRuntimePaths()) {
   const pidFile = pidFilePath(paths);
   const pid = await readPid(pidFile);
-  if (pid && !isProcessAlive3(pid)) {
+  if (pid && !isProcessAlive4(pid)) {
     await rm10(pidFile, { force: true }).catch(() => void 0);
     return {
       running: false,
@@ -42136,7 +43543,7 @@ async function readPid(filePath) {
   const pid = Number.parseInt(raw.trim(), 10);
   return Number.isInteger(pid) && pid > 0 ? pid : null;
 }
-function isProcessAlive3(pid) {
+function isProcessAlive4(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -42178,7 +43585,7 @@ function startSupervisorHealthMonitor(paths, child, write) {
       );
       terminateChild(child, forceKillTimer);
       forceKillTimer = setTimeout(() => {
-        if (child.pid && isProcessAlive3(child.pid)) {
+        if (child.pid && isProcessAlive4(child.pid)) {
           child.kill("SIGKILL");
         }
       }, SUPERVISOR_CHILD_STOP_TIMEOUT_MS);
@@ -42196,7 +43603,7 @@ function startSupervisorHealthMonitor(paths, child, write) {
         closed = true;
         terminateChild(child, forceKillTimer);
         forceKillTimer = setTimeout(() => {
-          if (child.pid && isProcessAlive3(child.pid)) {
+          if (child.pid && isProcessAlive4(child.pid)) {
             child.kill("SIGKILL");
           }
         }, SUPERVISOR_CHILD_STOP_TIMEOUT_MS);
@@ -42243,12 +43650,12 @@ function terminateChild(child, previousForceKillTimer) {
   if (previousForceKillTimer) {
     clearTimeout(previousForceKillTimer);
   }
-  if (child.pid && isProcessAlive3(child.pid)) {
+  if (child.pid && isProcessAlive4(child.pid)) {
     child.kill("SIGTERM");
   }
 }
 function supervisorStopIntentPath(paths) {
-  return path34.join(paths.runDir, "supervisor-stop-intent.json");
+  return path35.join(paths.runDir, "supervisor-stop-intent.json");
 }
 async function writeSupervisorStopIntent(paths, pid) {
   await mkdir16(paths.runDir, { recursive: true, mode: 448 });
@@ -42632,7 +44039,7 @@ async function readLinkUpdateStatus(paths) {
     };
     await writeUpdateState2(paths, state);
   }
-  if (state?.state === "running" && !runningUpdate2 && !isRecentRunningState3(state) && !isProcessAlive4(state.pid)) {
+  if (state?.state === "running" && !runningUpdate2 && !isRecentRunningState3(state) && !isProcessAlive5(state.pid)) {
     const reachedTarget = state.target_version && compareSemver3(LINK_VERSION, state.target_version) >= 0;
     state = reachedTarget ? {
       ...state,
@@ -42811,7 +44218,7 @@ async function buildOfficialInstallCommand(options, targetVersion) {
   };
 }
 function buildUnixInstallCommand(installerUrl) {
-  const nodeBinDir = path35.dirname(process.execPath);
+  const nodeBinDir = path36.dirname(process.execPath);
   const fetchScript = [
     quoteShellToken(process.execPath),
     "--input-type=module",
@@ -43081,10 +44488,10 @@ async function readUpdateLogLines2(paths) {
   );
 }
 function updateStatePath2(paths) {
-  return path35.join(paths.runDir, "link-update-state.json");
+  return path36.join(paths.runDir, "link-update-state.json");
 }
 function updateLogPath2(paths) {
-  return path35.join(paths.logsDir, UPDATE_LOG_FILE2);
+  return path36.join(paths.logsDir, UPDATE_LOG_FILE2);
 }
 async function clearUpdateLogFiles2(paths) {
   const primary = updateLogPath2(paths);
@@ -43145,7 +44552,7 @@ function linkUpdateTimeoutError() {
     LINK_UPDATE_TIMEOUT_MS / 6e4
   )} minutes.`;
 }
-function isProcessAlive4(pid) {
+function isProcessAlive5(pid) {
   if (!pid || pid <= 0) {
     return false;
   }
@@ -43168,7 +44575,7 @@ function readString26(payload, key) {
 }
 
 // src/pairing/pairing.ts
-import path36 from "path";
+import path37 from "path";
 import { rm as rm12 } from "fs/promises";
 
 // src/relay/bootstrap.ts
@@ -43508,10 +44915,10 @@ async function loadRequiredIdentity2(paths) {
   }
   return identity;
 }
-async function postServerJson(serverBaseUrl, path37, body, options) {
+async function postServerJson(serverBaseUrl, path38, body, options) {
   let response;
   try {
-    response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path37}`, {
+    response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path38}`, {
       method: "POST",
       headers: {
         accept: "application/json",
@@ -43559,10 +44966,10 @@ function pairingErrorSnapshot(stage, error) {
     occurred_at: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-async function patchServerJson(serverBaseUrl, path37, token, body, options) {
+async function patchServerJson(serverBaseUrl, path38, token, body, options) {
   let response;
   try {
-    response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path37}`, {
+    response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path38}`, {
       method: "PATCH",
       headers: {
         accept: "application/json",
@@ -43610,10 +45017,10 @@ function createPairingNetworkError(input) {
   );
 }
 function pairingClaimPath(sessionId, paths) {
-  return path36.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.claimed.json`);
+  return path37.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.claimed.json`);
 }
 function pairingSessionPath(sessionId, paths) {
-  return path36.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.json`);
+  return path37.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);
@@ -44155,7 +45562,7 @@ async function readActiveCronJobCount(profiles, logger) {
   }, 0);
 }
 function isActiveCronJob(job) {
-  const enabled = readBoolean3(job.enabled) ?? true;
+  const enabled = readBoolean4(job.enabled) ?? true;
   if (!enabled) {
     return false;
   }
@@ -44895,6 +46302,9 @@ function registerLiveActivityRoutes(router, options) {
         status_label: state.statusLabel,
         progress_text: state.progressText,
         detail_text: state.detailText ?? null,
+        todo_done_count: state.todoDoneCount ?? null,
+        todo_total_count: state.todoTotalCount ?? null,
+        todo_progress_text: state.todoProgressText ?? null,
         updated_at: state.updatedAt ?? null
       } : null
     };