@hermespilot/link 0.8.4 → 0.8.5

package/dist/{chunk-VVHNBT4E.js → chunk-QT55LT5X.js}

@@ -7721,7 +7721,7 @@ function isConversationMissingError(error) {
 }
 
 // src/constants.ts
-var LINK_VERSION = "0.8.4";
+var LINK_VERSION = "0.8.5";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -10966,6 +10966,8 @@ async function dispatchTuiGatewayCommand(input) {
     output: readString5(result, "output") ?? void 0,
     notice: readString5(result, "notice") ?? void 0,
     message: readString5(result, "message") ?? void 0,
+    runtimeSessionId: started.runtimeSessionId,
+    storedSessionId: started.storedSessionId,
     raw: result
   };
 }
@@ -14555,6 +14557,9 @@ function applyAppMessagePresentation(message) {
   }
   const text = messageText(message);
   if (isHermesImportedMessage(message)) {
+    if (message.role === "user" && isHermesGoalContinuationPrompt(text)) {
+      return { ...message, visibility: "internal" };
+    }
     const strippedText = stripLeadingHermesInternalNote(text);
     if (strippedText !== text) {
       return strippedText ? withText(message, strippedText) : { ...message, visibility: "internal" };
@@ -14600,6 +14605,9 @@ function linkLifecycleMarkerPresentation(message) {
 function isHermesImportedMessage(message) {
   return message.hermes?.imported_from === "hermes" || HERMES_IMPORTED_MESSAGE_FORMATS.has(message.raw?.format ?? "");
 }
+function isHermesGoalContinuationPrompt(text) {
+  return text.replace(/\r\n/gu, "\n").startsWith("[Continuing toward your standing goal]\nGoal:");
+}
 function isHermesInternalSystemStyleMarker(text) {
   const normalized = text.trim();
   return normalized.startsWith(
@@ -15932,6 +15940,9 @@ function collectHermesSessionIds(manifest, snapshot) {
   return normalizeHermesSessionIds([
     manifest.hermes_session_id,
     ...manifest.hermes_session_ids ?? [],
+    manifest.hermes_lineage?.root_session_id,
+    manifest.hermes_lineage?.current_session_id,
+    ...manifest.hermes_lineage?.session_ids ?? [],
     ...Object.values(manifest.profile_session_ids ?? {}),
     ...snapshot.runs.map((run) => run.hermes_session_id)
   ]);
@@ -15960,6 +15971,11 @@ function collectHermesSessionDeleteTargets(manifest, snapshot) {
   for (const sessionId of manifest.hermes_session_ids ?? []) {
     add(sessionId, defaultProfile);
   }
+  add(manifest.hermes_lineage?.root_session_id, defaultProfile);
+  add(manifest.hermes_lineage?.current_session_id, defaultProfile);
+  for (const sessionId of manifest.hermes_lineage?.session_ids ?? []) {
+    add(sessionId, defaultProfile);
+  }
   for (const [profileName, sessionId] of Object.entries(
     manifest.profile_session_ids ?? {}
   )) {
@@ -18245,6 +18261,13 @@ var ConversationOrchestrationCoordinator = class {
       attachments: userAttachmentParts,
       language: normalizeLanguage(input.language)
     }) : null;
+    if (goalRequest?.hermesSessionId) {
+      manifest = addHermesSessionIdForProfileToManifest(
+        manifest,
+        goalRequest.hermesSessionId,
+        runtime.profileName
+      );
+    }
     if ((hasRunningRuns(snapshot) || queuedRunCount(snapshot) > 0) && queuedRunCount(snapshot) >= MAX_CONVERSATION_QUEUED_RUNS) {
       throw new LinkHttpError(
         409,
@@ -18459,6 +18482,7 @@ var ConversationOrchestrationCoordinator = class {
         maxTurns: readGoalProgressFromStatusText(result.notice ?? result.output ?? "").maxTurns
       }),
       kickoffInput: result.message.trim(),
+      ...result.storedSessionId ? { hermesSessionId: result.storedSessionId } : {},
       ...result.notice ? { notice: result.notice } : {},
       ...result.output ? { output: result.output } : {}
     };
@@ -20240,6 +20264,40 @@ var ContextCompressionCoordinator = class {
   hasActiveCompression(snapshot) {
     return snapshot.runs.some((run) => isActiveCompressionRun(run));
   }
+  async repairDetachedRunningCompressions(conversationId) {
+    const snapshot = await this.deps.store.readSnapshot(conversationId).catch(() => null);
+    const candidates = snapshot?.runs.filter(
+      (run) => isActiveCompressionRun(run) && !this.activeOperations.has(run.context_compression.operation_id)
+    ) ?? [];
+    let repaired = false;
+    for (const run of candidates) {
+      const operation = run.context_compression;
+      if (!operation) {
+        continue;
+      }
+      const markerId = run.assistant_message_id;
+      await this.finishCompression({
+        conversationId,
+        runId: run.id,
+        markerId,
+        operationId: operation.operation_id,
+        generation: operation.generation,
+        status: "failed",
+        error: new LinkHttpError(
+          502,
+          "context_compression_detached",
+          localizedText(
+            normalizeLanguage2(run.language),
+            "Hermes Link \u5DF2\u5931\u53BB\u8FD9\u6B21\u4E0A\u4E0B\u6587\u538B\u7F29\u7684\u5B9E\u65F6\u8FDE\u63A5\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002",
+            "Hermes Link lost the realtime connection for this context compression. Try again shortly."
+          )
+        ),
+        language: normalizeLanguage2(run.language)
+      });
+      repaired = true;
+    }
+    return repaired;
+  }
   async startLocked(input) {
     const focus = normalizeFocus(input.focus);
     const language = normalizeLanguage2(input.language);
@@ -21675,15 +21733,6 @@ async function syncHermesConversationMessages(paths, logger, input) {
   for (const candidate of candidates) {
     try {
       const candidateMessages = await readHermesLineageMessages(candidate);
-      if (candidateMessages.length === 0) {
-        continue;
-      }
-      const missingCandidateMessages = candidateMessages.filter(
-        (message, index) => !isRepresentedHermesRow(representedRows, message, index)
-      );
-      if (missingCandidateMessages.length === 0) {
-        continue;
-      }
       const profile = await resolveConversationProfileTarget(
         paths,
         candidate.profileName
@@ -21693,6 +21742,15 @@ async function syncHermesConversationMessages(paths, logger, input) {
         profileUid: profile.profileUid,
         profileName: profile.profileName
       });
+      if (candidateMessages.length === 0) {
+        continue;
+      }
+      const missingCandidateMessages = candidateMessages.filter(
+        (message, index) => !isRepresentedHermesRow(representedRows, message, index)
+      );
+      if (missingCandidateMessages.length === 0) {
+        continue;
+      }
       projectedMessages.push(
         ...toLinkMessages({
           conversationId: input.conversationId,
@@ -21726,13 +21784,55 @@ async function syncHermesConversationMessages(paths, logger, input) {
     exactKeys.forEach((key) => knownExactKeys.add(key));
   }
   if (appendedMessages.length === 0) {
+    let nextManifest2 = candidateProfiles.size > 0 || duplicateCleanup.removedCount > 0 ? await store.readManifest(input.conversationId) : null;
+    const currentManifest = nextManifest2;
+    let lineageChanged = false;
+    if (nextManifest2) {
+      for (const profile of candidateProfiles.values()) {
+        nextManifest2 = mergeHermesLineageIntoManifest({
+          manifest: nextManifest2,
+          candidate: profile.candidate,
+          snapshot,
+          profileUid: profile.profileUid,
+          profileName: profile.profileName,
+          updatedAt: isoFromHermesTime(profile.candidate.session.last_active) ?? nextManifest2.updated_at
+        });
+      }
+      lineageChanged = !manifestEquivalent(currentManifest, nextManifest2);
+      if (duplicateCleanup.removedCount > 0) {
+        nextManifest2 = {
+          ...nextManifest2,
+          stats: buildConversationStats(nextManifest2, snapshot)
+        };
+      }
+    }
     if (duplicateCleanup.removedCount > 0) {
       await store.writeSnapshot(input.conversationId, snapshot);
-      const currentManifest = await store.readManifest(input.conversationId);
-      const stats2 = buildConversationStats(currentManifest, snapshot);
-      const nextManifest2 = { ...currentManifest, stats: stats2 };
+    }
+    if (nextManifest2 && currentManifest && (duplicateCleanup.removedCount > 0 || lineageChanged)) {
+      const stats2 = buildConversationStats(nextManifest2, snapshot);
+      nextManifest2 = { ...nextManifest2, stats: stats2 };
       await store.writeManifest(nextManifest2);
       await upsertConversationStats(paths, toStatsIndexRecord(nextManifest2, stats2));
+      result.hermes_session_ids = manifestHermesSessionIds(nextManifest2);
+      result.changed = true;
+      if (lineageChanged) {
+        const appendEvent2 = input.appendEvent ?? ((conversationId, event2) => store.appendEvent(conversationId, event2));
+        const event = await appendEvent2(input.conversationId, {
+          type: "conversation.updated",
+          payload: {
+            source: "hermes_sync",
+            hermes_session_id: nextManifest2.hermes_session_id,
+            hermes_session_ids: manifestHermesSessionIds(nextManifest2),
+            conversation: await summarizeSyncedConversation(
+              paths,
+              nextManifest2,
+              snapshot
+            )
+          }
+        });
+        result.last_event_seq = event.seq;
+      }
     }
     return result;
   }
@@ -21773,6 +21873,7 @@ async function syncHermesConversationMessages(paths, logger, input) {
   };
   await store.writeManifest(nextManifest);
   await upsertConversationStats(paths, toStatsIndexRecord(nextManifest, stats));
+  result.hermes_session_ids = manifestHermesSessionIds(nextManifest);
   const appendEvent = input.appendEvent ?? ((conversationId, event) => store.appendEvent(conversationId, event));
   let lastEventSeq;
   for (const message of hydratedAppendedMessages) {
@@ -22162,6 +22263,18 @@ function isStrictImportedDuplicateRunMessage(paths, snapshot, message) {
     if (!isMessageInsideRunCleanupWindow(message, run)) {
       return false;
     }
+    if (isImportedMessageCoveredByRunWindow(message, run)) {
+      if (message.role === "user") {
+        return snapshot.messages.some(
+          (item) => item.id === run.trigger_message_id
+        );
+      }
+      if (message.role === "assistant" || message.role === "tool") {
+        return snapshot.messages.some(
+          (item) => item.id === run.assistant_message_id
+        );
+      }
+    }
     if (message.role === "user") {
       const user = snapshot.messages.find(
         (item) => item.id === run.trigger_message_id
@@ -22177,6 +22290,20 @@ function isStrictImportedDuplicateRunMessage(paths, snapshot, message) {
     return false;
   });
 }
+function isImportedMessageCoveredByRunWindow(message, run) {
+  const rows = readHermesRawMessageRows(message.raw);
+  if (rows.length === 0) {
+    return false;
+  }
+  const windows = collectRunHermesMessageWindows(run);
+  if (windows.length === 0) {
+    return false;
+  }
+  return rows.every((row) => {
+    const role = normalizeMessageRole(row.role);
+    return windows.some((window) => isRowInsideRunWindow(window, row, role));
+  });
+}
 function isDuplicateImportedRunUser(paths, user, imported) {
   const importedText = normalizedDuplicateText(imported);
   if (!importedText) {
@@ -22249,7 +22376,7 @@ function normalizedDuplicateTextValue(value) {
   return value.replace(/\r\n/gu, "\n").trim();
 }
 function collectRunHermesMessageWindows(run) {
-  const before = normalizeWatermarkPoint(
+  let before = normalizeWatermarkPoint(
     run.hermes_message_watermark?.before,
     run.hermes_session_id
   );
@@ -22260,10 +22387,15 @@ function collectRunHermesMessageWindows(run) {
     run.hermes_message_watermark?.after,
     run.hermes_session_id
   );
-  const sessionId = before.session_id?.trim() || run.hermes_session_id?.trim();
+  const beforeSessionId = before.session_id?.trim();
+  const afterSessionId = after?.session_id?.trim();
+  const sessionId = beforeSessionId && isPlaceholderHermesSessionId(beforeSessionId) && afterSessionId && !isPlaceholderHermesSessionId(afterSessionId) ? afterSessionId : beforeSessionId || run.hermes_session_id?.trim();
   if (!sessionId) {
     return [];
   }
+  if (before.session_id !== sessionId) {
+    before = { ...before, session_id: sessionId };
+  }
   return [
     {
       runId: run.id,
@@ -22387,6 +22519,9 @@ function isRowInsideRunWindow(window, row, role) {
   const upperTimeMs = hermesTimestampMillis(window.after?.max_timestamp) ?? (allowTerminalGrace && window.completedAtMs !== void 0 ? window.completedAtMs + 2 * 60 * 1e3 : allowOpenEnded ? Number.POSITIVE_INFINITY : void 0);
   return upperTimeMs !== void 0 && (beforeTimeMs !== void 0 ? rowTimeMs > lowerTimeMs : rowTimeMs >= lowerTimeMs) && rowTimeMs <= upperTimeMs;
 }
+function isPlaceholderHermesSessionId(sessionId) {
+  return sessionId.startsWith("hp_");
+}
 function isVoicePart(part) {
   return part.kind === "voice" || part.is_voice_note === true;
 }
@@ -22474,6 +22609,16 @@ function lineageSessionIds(candidate) {
     candidate.session.id
   ]);
 }
+function manifestHermesSessionIds(manifest) {
+  return normalizeSessionIds([
+    manifest.hermes_session_id,
+    ...manifest.hermes_session_ids ?? [],
+    manifest.hermes_lineage?.root_session_id,
+    manifest.hermes_lineage?.current_session_id,
+    ...manifest.hermes_lineage?.session_ids ?? [],
+    ...Object.values(manifest.profile_session_ids ?? {})
+  ]);
+}
 function lineageTitle(candidate) {
   const explicitLineageTitle = normalizeOptionalTitle(
     candidate.session._lineage_title
@@ -22735,6 +22880,13 @@ function mergeHermesLineageIntoManifest(input) {
 function manifestEquivalent(left, right) {
   return stableJson(left) === stableJson(right);
 }
+async function summarizeSyncedConversation(paths, manifest, snapshot) {
+  return toSummary(
+    manifest,
+    snapshot,
+    await readConversationProfileSummary(paths, manifest)
+  );
+}
 function collectImportedHermesPrefix(snapshot) {
   const rows = [];
   const seen = /* @__PURE__ */ new Set();
@@ -29665,6 +29817,309 @@ ${resolved}` : resolved;
       return true;
     });
   }
+  async repairStaleAutomaticContextCompression(conversationId) {
+    const terminalRepaired = await this.deps.withConversationLock(
+      conversationId,
+      async () => {
+        const snapshot = await this.deps.readSnapshot(conversationId);
+        const cleared = [];
+        for (const run of snapshot.runs) {
+          const status = staleAutomaticContextCompressionStatus(run);
+          if (!status) {
+            continue;
+          }
+          const result = this.clearAutomaticContextCompressionInSnapshot({
+            snapshot,
+            run,
+            status,
+            completedAt: run.completed_at ?? (/* @__PURE__ */ new Date()).toISOString()
+          });
+          if (result) {
+            cleared.push({ run, ...result });
+          }
+        }
+        if (cleared.length === 0) {
+          return false;
+        }
+        await this.deps.writeSnapshot(conversationId, snapshot);
+        for (const item of cleared) {
+          await this.appendAutomaticContextCompressionClearedEvent({
+            conversationId,
+            run: item.run,
+            marker: item.marker,
+            metadata: item.metadata
+          });
+        }
+        await this.deps.persistConversationStats(conversationId, snapshot);
+        return true;
+      }
+    );
+    const detachedRunningRepaired = await this.repairDetachedRunningAutomaticContextCompression(conversationId);
+    return terminalRepaired || detachedRunningRepaired;
+  }
+  async repairStaleConversationRuns(conversationId) {
+    const compressionRepaired = await this.repairStaleAutomaticContextCompression(conversationId);
+    const snapshot = await this.deps.readSnapshot(conversationId).catch(() => null);
+    const candidates = snapshot?.runs.filter(
+      (run) => run.status === "running" && run.kind !== "compression" && run.context_compression?.status !== "compressing" && !isRunningAutomaticContextCompression(run)
+    ) ?? [];
+    let repaired = compressionRepaired;
+    let shouldDrainQueue = compressionRepaired;
+    let pending = false;
+    for (const run of candidates) {
+      const result = await this.repairDetachedRunningRun(conversationId, run);
+      if (result.repaired) {
+        repaired = true;
+      }
+      if (result.shouldDrainQueue) {
+        shouldDrainQueue = true;
+      }
+      if (result.pending) {
+        pending = true;
+      }
+    }
+    return { repaired, shouldDrainQueue, pending };
+  }
+  async repairDetachedRunningAutomaticContextCompression(conversationId) {
+    const snapshot = await this.deps.readSnapshot(conversationId).catch(() => null);
+    const candidates = snapshot?.runs.filter(
+      (run) => isRunningAutomaticContextCompression(run)
+    ) ?? [];
+    let repaired = false;
+    for (const run of candidates) {
+      const previousSessionId = run.context_compression?.previous_session_id?.trim() || run.hermes_session_id;
+      const nextSessionId = await readHermesCompressionTip(
+        previousSessionId,
+        this.deps.paths,
+        run.profile
+      ).catch(() => void 0);
+      if (!nextSessionId || nextSessionId === previousSessionId) {
+        continue;
+      }
+      const finished = await this.finishAutomaticContextCompressionFromEvent({
+        conversationId,
+        runId: run.id,
+        previousSessionId,
+        nextSessionId
+      });
+      if (!finished) {
+        continue;
+      }
+      this.abortAndForgetActiveRunController(run.id);
+      await this.completeRun(conversationId, run.id);
+      repaired = true;
+    }
+    return repaired;
+  }
+  async repairDetachedRunningRun(conversationId, candidate) {
+    const snapshot = await this.deps.readSnapshot(conversationId).catch(() => null);
+    const run = snapshot?.runs.find((item) => item.id === candidate.id);
+    if (!run || run.status !== "running") {
+      return { repaired: false, shouldDrainQueue: false };
+    }
+    const backend = run.hermes_backend ?? (run.hermes_run_id ? "runs" : run.hermes_rpc_session_id ? "tui_gateway" : void 0);
+    const language = run.language === "en" ? "en" : "zh-CN";
+    if (backend === "runs" && run.hermes_run_id) {
+      const terminal = await this.readRunTerminalEventOnce({
+        conversationId,
+        run,
+        language
+      });
+      if (terminal.event) {
+        this.abortAndForgetActiveRunController(run.id);
+        const handled = await this.handleNormalizedHermesEvent({
+          backend: "runs",
+          conversationId,
+          runId: run.id,
+          event: terminal.event,
+          profileName: run.profile,
+          cronJobIdsBeforeRun: null
+        });
+        if (handled) {
+          this.deps.scheduleTitleRefresh(conversationId);
+          return { repaired: true, shouldDrainQueue: true };
+        }
+      }
+      if (terminal.pending) {
+        return { repaired: false, shouldDrainQueue: false, pending: true };
+      }
+    }
+    if (backend === "tui_gateway" && run.hermes_rpc_session_id) {
+      const liveSession = await readTuiGatewayLiveSession({
+        profileName: run.profile,
+        runtimeSessionId: run.hermes_rpc_session_id,
+        storedSessionId: run.hermes_session_id,
+        logger: this.deps.logger,
+        paths: this.deps.paths
+      }).catch((error) => {
+        void this.deps.logger.debug("stale_tui_gateway_live_probe_failed", {
+          conversation_id: conversationId,
+          run_id: run.id,
+          hermes_rpc_session_id: run.hermes_rpc_session_id,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return null;
+      });
+      if (liveSession?.running) {
+        await this.deps.logger.debug("stale_run_left_running_live_session", {
+          conversation_id: conversationId,
+          run_id: run.id,
+          hermes_rpc_session_id: run.hermes_rpc_session_id,
+          upstream_status: liveSession.status
+        });
+        return { repaired: false, shouldDrainQueue: false, pending: true };
+      }
+    }
+    if (await this.runHasDisplayableAssistantOutput(conversationId, run.id)) {
+      this.abortAndForgetActiveRunController(run.id);
+      await this.completeRun(conversationId, run.id);
+      this.deps.scheduleTitleRefresh(conversationId);
+      return { repaired: true, shouldDrainQueue: true };
+    }
+    const recovered = await this.recoverDetachedRunFromHermesTranscript({
+      conversationId,
+      run
+    });
+    if (recovered) {
+      this.abortAndForgetActiveRunController(run.id);
+      this.deps.scheduleTitleRefresh(conversationId);
+      return { repaired: true, shouldDrainQueue: true };
+    }
+    const stillRunning = await this.deps.readSnapshot(conversationId).then(
+      (latest) => latest.runs.some(
+        (item) => item.id === run.id && item.status === "running"
+      )
+    ).catch(() => false);
+    if (!stillRunning || this.deps.activeRunControllers.has(run.id)) {
+      return { repaired: false, shouldDrainQueue: false };
+    }
+    await this.failRun(
+      conversationId,
+      run.id,
+      detachedRunRecoveryFailedMessage(language)
+    );
+    return { repaired: true, shouldDrainQueue: true };
+  }
+  abortAndForgetActiveRunController(runId) {
+    const active = this.deps.activeRunControllers.get(runId);
+    active?.controller.abort();
+    this.deps.activeRunControllers.delete(runId);
+  }
+  async readRunTerminalEventOnce(input) {
+    const hermesRunId = input.run.hermes_run_id;
+    if (!hermesRunId) {
+      return { event: null, pending: false };
+    }
+    let status;
+    try {
+      status = await readHermesRunStatus(hermesRunId, {
+        logger: this.deps.logger,
+        profileName: input.run.profile,
+        language: input.language
+      });
+    } catch (error) {
+      await this.deps.logger.warn("stale_run_status_probe_failed", {
+        conversation_id: input.conversationId,
+        run_id: input.run.id,
+        hermes_run_id: hermesRunId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return { event: null, pending: false };
+    }
+    if (!status) {
+      return { event: null, pending: false };
+    }
+    if (status.session_id) {
+      await this.rememberRunHermesSessionId(
+        input.conversationId,
+        input.run.id,
+        status.session_id
+      );
+    }
+    return {
+      event: hermesRunStatusToTerminalEvent(status),
+      pending: !isTerminalRunStatus(status.status)
+    };
+  }
+  async recoverDetachedRunFromHermesTranscript(input) {
+    const recoveredText = await readRunFinalAssistantText({
+      profileName: input.run.profile,
+      hermesSessionId: input.run.hermes_session_id,
+      runStartedAt: input.run.started_at
+    }).catch(async (error) => {
+      await this.deps.logger.warn("stale_run_transcript_recovery_read_failed", {
+        conversation_id: input.conversationId,
+        run_id: input.run.id,
+        hermes_session_id: input.run.hermes_session_id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    });
+    if (!recoveredText?.trim()) {
+      return false;
+    }
+    await this.persistHermesEvent(
+      input.conversationId,
+      input.run.id,
+      transcriptRecoveryDeltaEvent(input.run.hermes_session_id, recoveredText)
+    );
+    await this.completeRun(
+      input.conversationId,
+      input.run.id,
+      transcriptRecoveryCompletedEvent(input.run.hermes_session_id)
+    );
+    await this.deps.logger.info("stale_run_transcript_recovered", {
+      conversation_id: input.conversationId,
+      run_id: input.run.id,
+      hermes_session_id: input.run.hermes_session_id,
+      content_length: recoveredText.length
+    });
+    return true;
+  }
+  clearAutomaticContextCompressionInSnapshot(input) {
+    if (input.run.context_compression?.status !== "compressing" || input.run.context_compression.source !== "auto") {
+      return null;
+    }
+    const marker = findContextCompressionMarker(
+      input.snapshot,
+      input.run.context_compression.operation_id
+    );
+    if (!marker) {
+      return null;
+    }
+    const metadata = {
+      ...input.run.context_compression,
+      status: input.status,
+      completed_at: input.completedAt
+    };
+    input.run.context_compression = metadata;
+    updateContextCompressionMarker({
+      message: marker,
+      metadata,
+      language: input.run.language === "en" ? "en" : "zh-CN"
+    });
+    return { marker, metadata };
+  }
+  async appendAutomaticContextCompressionClearedEvent(input) {
+    await this.deps.appendEvent(input.conversationId, {
+      type: contextCompressionClearedEventType(input.metadata.status),
+      message_id: input.marker.id,
+      run_id: input.run.id,
+      payload: {
+        message: input.marker,
+        run: input.run,
+        operation: input.metadata,
+        automatic: true,
+        session_rotated: false
+      },
+      ...input.event ? {
+        raw: {
+          format: "hermes-run-event",
+          payload: input.event.rawPayload
+        }
+      } : {}
+    });
+  }
   async runHasAssistantOutput(conversationId, runId) {
     const snapshot = await this.deps.readSnapshot(conversationId).catch(() => null);
     const run = snapshot?.runs.find((item) => item.id === runId);
@@ -29676,6 +30131,17 @@ ${resolved}` : resolved;
     }
     return messageText2(assistant).length > 0 || (assistant.agent_events?.length ?? 0) > 0 || (assistant.approvals?.length ?? 0) > 0 || assistant.parts.some((part) => part.type !== "text");
   }
+  async runHasDisplayableAssistantOutput(conversationId, runId) {
+    const snapshot = await this.deps.readSnapshot(conversationId).catch(() => null);
+    const run = snapshot?.runs.find((item) => item.id === runId);
+    const assistant = snapshot?.messages.find(
+      (item) => item.id === run?.assistant_message_id
+    );
+    if (!assistant) {
+      return false;
+    }
+    return messageText2(assistant).trim().length > 0 || assistant.parts.some((part) => part.type !== "text");
+  }
   async appendAssistantTextFromCompletedResponse(conversationId, runId, event) {
     const terminalText = extractResponseAssistantText(event.payload);
     if (!terminalText?.trim()) {
@@ -30228,6 +30694,12 @@ ${details.join("\n")}` : localizedEmptyHermesResponseMessage(language);
       );
     }
     const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const clearedCompression = this.clearAutomaticContextCompressionInSnapshot({
+      snapshot,
+      run,
+      status: "completed",
+      completedAt
+    });
     const usage = readUsage(source?.payload);
     const responseId = readResponseId(source?.payload);
     const hermesRunId = readRunId(source?.payload);
@@ -30328,6 +30800,15 @@ ${details.join("\n")}` : localizedEmptyHermesResponseMessage(language);
       runId,
       expiredInputRequests
     );
+    if (clearedCompression) {
+      await this.appendAutomaticContextCompressionClearedEvent({
+        conversationId,
+        run,
+        marker: clearedCompression.marker,
+        metadata: clearedCompression.metadata,
+        event: source
+      });
+    }
     if (assistant) {
       await this.deps.appendEvent(conversationId, {
         type: "message.completed",
@@ -30404,6 +30885,12 @@ ${details.join("\n")}` : localizedEmptyHermesResponseMessage(language);
     }
     run.status = "failed";
     run.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+    const clearedCompression = this.clearAutomaticContextCompressionInSnapshot({
+      snapshot,
+      run,
+      status: "failed",
+      completedAt: run.completed_at
+    });
     run.error_message = message;
     run.error_detail = source ? readErrorMessage4(source.payload) ?? void 0 : void 0;
     const language = run.language === "en" ? "en" : "zh-CN";
@@ -30454,6 +30941,15 @@ ${details.join("\n")}` : localizedEmptyHermesResponseMessage(language);
       runId,
       expiredInputRequests
     );
+    if (clearedCompression) {
+      await this.appendAutomaticContextCompressionClearedEvent({
+        conversationId,
+        run,
+        marker: clearedCompression.marker,
+        metadata: clearedCompression.metadata,
+        event: source
+      });
+    }
     const contextUsage = contextUsagePayloadForSnapshot(snapshot);
     await this.deps.appendEvent(conversationId, {
       type: "run.failed",
@@ -30682,6 +31178,12 @@ ${details.join("\n")}` : localizedEmptyHermesResponseMessage(language);
     const cancelledAt = (/* @__PURE__ */ new Date()).toISOString();
     run.status = "cancelled";
     run.completed_at = cancelledAt;
+    const clearedCompression = this.clearAutomaticContextCompressionInSnapshot({
+      snapshot,
+      run,
+      status: "cancelled",
+      completedAt: cancelledAt
+    });
     run.error_message = options.reason;
     const cancelledByGoalPause = options.reason === "goal paused by app";
     const assistant = snapshot.messages.find(
@@ -30723,6 +31225,14 @@ ${details.join("\n")}` : localizedEmptyHermesResponseMessage(language);
       runId,
       cancelledInputRequests
     );
+    if (clearedCompression) {
+      await this.appendAutomaticContextCompressionClearedEvent({
+        conversationId,
+        run,
+        marker: clearedCompression.marker,
+        metadata: clearedCompression.metadata
+      });
+    }
     if (assistant) {
       await this.deps.appendEvent(conversationId, {
         type: "message.completed",
@@ -30975,6 +31485,36 @@ function contextCompressionGeneration(message) {
 function readPreviousSessionId(payload) {
   return readString21(payload, "old_session_id") ?? readString21(payload, "oldSessionId") ?? readString21(payload, "previous_session_id") ?? readString21(payload, "previousSessionId");
 }
+function contextCompressionClearedEventType(status) {
+  if (status === "completed") {
+    return "context_compression.completed";
+  }
+  if (status === "cancelled") {
+    return "context_compression.cancelled";
+  }
+  if (status === "timed_out") {
+    return "context_compression.timed_out";
+  }
+  return "context_compression.failed";
+}
+function staleAutomaticContextCompressionStatus(run) {
+  if (run.context_compression?.status !== "compressing" || run.context_compression.source !== "auto") {
+    return null;
+  }
+  if (run.status === "completed") {
+    return "completed";
+  }
+  if (run.status === "failed") {
+    return "failed";
+  }
+  if (run.status === "cancelled") {
+    return "cancelled";
+  }
+  return null;
+}
+function isRunningAutomaticContextCompression(run) {
+  return run.status === "running" && run.context_compression?.status === "compressing" && run.context_compression.source === "auto";
+}
 function readNextSessionId(payload) {
   const info = toRecord19(payload.info);
   return readString21(payload, "session_key") ?? readString21(payload, "sessionKey") ?? readString21(payload, "stored_session_id") ?? readString21(payload, "storedSessionId") ?? readString21(payload, "session_id") ?? readString21(payload, "sessionId") ?? readString21(info, "session_key") ?? readString21(info, "sessionKey");
@@ -31410,6 +31950,62 @@ function transcriptRecoveryCompletedEvent(hermesSessionId) {
     }
   };
 }
+function hermesRunStatusToTerminalEvent(status) {
+  if (!status) {
+    return null;
+  }
+  const normalizedStatus = status.status.trim().toLowerCase();
+  if (isCompletedRunStatus(normalizedStatus)) {
+    return {
+      eventName: "run.completed",
+      payloadType: "run.completed",
+      payload: {
+        type: "run.completed",
+        run_id: status.run_id,
+        output: status.output,
+        usage: status.usage,
+        status: status.status
+      },
+      rawPayload: status.raw
+    };
+  }
+  if (isFailedRunStatus(normalizedStatus)) {
+    return {
+      eventName: "run.failed",
+      payloadType: "run.failed",
+      payload: {
+        type: "run.failed",
+        run_id: status.run_id,
+        error: {
+          message: readStatusErrorMessage(status.error) ?? "Hermes run failed"
+        },
+        status: status.status,
+        usage: status.usage
+      },
+      rawPayload: status.raw
+    };
+  }
+  if (isCancelledRunStatus(normalizedStatus)) {
+    return {
+      eventName: "run.cancelled",
+      payloadType: "run.cancelled",
+      payload: {
+        type: "run.cancelled",
+        run_id: status.run_id,
+        status: status.status
+      },
+      rawPayload: status.raw
+    };
+  }
+  return null;
+}
+function detachedRunRecoveryFailedMessage(language) {
+  return localizedRunText(
+    language,
+    "Hermes Link \u5DF2\u5931\u53BB\u8FD9\u6B21\u8FD0\u884C\u7684\u5B9E\u65F6\u8FDE\u63A5\uFF0C\u4E14\u65E0\u6CD5\u4ECE Hermes \u672C\u5730\u8BB0\u5F55\u6062\u590D\u6700\u7EC8\u7ED3\u679C\u3002\u8BF7\u91CD\u65B0\u53D1\u9001\uFF0C\u6216\u5728 Hermes Desktop \u4E2D\u67E5\u770B\u8BE5\u4F1A\u8BDD\u3002",
+    "Hermes Link lost the realtime connection for this run and could not recover the final result from local Hermes records. Send the message again, or check this conversation in Hermes Desktop."
+  );
+}
 function readResponseId(payload) {
   if (!payload) {
     return null;
@@ -31432,6 +32028,10 @@ function isFailedRunStatus(status) {
 function isCancelledRunStatus(status) {
   return status === "cancelled" || status === "canceled" || status === "stopped" || status === "aborted";
 }
+function isTerminalRunStatus(status) {
+  const normalized = status.trim().toLowerCase();
+  return isCompletedRunStatus(normalized) || isFailedRunStatus(normalized) || isCancelledRunStatus(normalized);
+}
 function isTerminalConversationGoalStatus(status) {
   return status === "done" || status === "paused" || status === "cleared";
 }
@@ -31536,6 +32136,13 @@ function isNodeError18(error, code) {
 // src/conversations/conversation-service.ts
 var ALL_CONVERSATION_EVENTS = "conversation:*";
 var HERMES_ARCHIVE_STATE_SYNC_ID = "hermes-agent-archive-state-v1";
+var STALE_RUN_REPAIR_RETRY_DELAYS_MS = [
+  2e3,
+  5e3,
+  15e3,
+  3e4,
+  6e4
+];
 function runtimeMatchesConfiguredModel(runtime, model) {
   return runtime.model.id === model.id && (runtime.model.provider_key ?? runtime.model.provider ?? "") === model.provider && normalizeModelEndpoint(runtime.model.base_url) === normalizeModelEndpoint(model.baseUrl) && (runtime.model.api_mode ?? "") === (model.apiMode ?? "");
 }
@@ -31656,6 +32263,8 @@ var ConversationService = class {
   runLifecycle;
   hermesSessionSyncPromise = null;
   cronDeliverySyncPromise = null;
+  staleRunRepairRetryAttempts = /* @__PURE__ */ new Map();
+  staleRunRepairRetryTimers = /* @__PURE__ */ new Map();
   async withConversationLock(conversationId, task) {
     const previous = this.conversationLocks.get(conversationId) ?? Promise.resolve();
     let release;
@@ -31700,19 +32309,34 @@ var ConversationService = class {
     return this.store.readActiveManifest(conversationId);
   }
   async listConversations() {
-    return this.queries.listConversations();
+    return this.repairStaleConversationSummaries(
+      await this.queries.listConversations(),
+      () => this.queries.listConversations()
+    );
   }
-  listConversationPage(input = {}) {
-    return this.queries.listConversationPage(input);
+  async listConversationPage(input = {}) {
+    return this.repairStaleConversationListPage(
+      await this.queries.listConversationPage(input),
+      () => this.queries.listConversationPage(input)
+    );
   }
-  searchConversationPage(input = {}) {
-    return this.queries.searchConversationPage(input);
+  async searchConversationPage(input = {}) {
+    return this.repairStaleConversationListPage(
+      await this.queries.searchConversationPage(input),
+      () => this.queries.searchConversationPage(input)
+    );
   }
-  listArchivedConversationPage(input = {}) {
-    return this.queries.listArchivedConversationPage(input);
+  async listArchivedConversationPage(input = {}) {
+    return this.repairStaleConversationListPage(
+      await this.queries.listArchivedConversationPage(input),
+      () => this.queries.listArchivedConversationPage(input)
+    );
   }
-  searchArchivedConversationPage(input = {}) {
-    return this.queries.searchArchivedConversationPage(input);
+  async searchArchivedConversationPage(input = {}) {
+    return this.repairStaleConversationListPage(
+      await this.queries.searchArchivedConversationPage(input),
+      () => this.queries.searchArchivedConversationPage(input)
+    );
   }
   async getStatistics(filter = {}) {
     return readLinkStatistics(this.paths, filter);
@@ -32277,14 +32901,15 @@ 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)
-          });
-        }
-      );
+      await this.repairAndSyncConversation(conversationId, "messages_read");
+    } else if (!options.beforeMessageId) {
+      const repaired = await this.repairStaleConversationRuns(conversationId);
+      if (repaired) {
+        await this.syncHermesConversationMessagesBestEffort(
+          conversationId,
+          "messages_read_after_repair"
+        );
+      }
     }
     return this.queries.getMessages(conversationId, options);
   }
@@ -32310,6 +32935,7 @@ var ConversationService = class {
         "model_id or reasoning_effort is required"
       );
     }
+    await this.repairAndSyncConversationBeforeWrite(conversationId);
     return this.withConversationLock(conversationId, async () => {
       let manifest = await this.restoreArchivedConversationForUserContinuationLocked(
         conversationId
@@ -32429,6 +33055,7 @@ var ConversationService = class {
     });
   }
   async setConversationProfile(conversationId, profileName) {
+    await this.repairAndSyncConversationBeforeWrite(conversationId);
     return this.withConversationLock(conversationId, async () => {
       let manifest = await this.store.readRunnableManifest(conversationId);
       const snapshot = await this.store.readSnapshot(conversationId);
@@ -32585,6 +33212,7 @@ var ConversationService = class {
     };
   }
   async listEvents(conversationId, after = 0) {
+    await this.repairStaleConversationRuns(conversationId);
     return (await this.queries.listEvents(conversationId, after)).map(toAppVisibleConversationEvent).filter((event) => event !== null);
   }
   subscribe(conversationId, listener) {
@@ -32622,15 +33250,19 @@ var ConversationService = class {
     return manifest?.status === "active";
   }
   async sendMessage(input) {
+    await this.repairAndSyncConversationBeforeWrite(input.conversationId);
     return this.orchestration.sendMessage(input);
   }
   async setGoalPaused(conversationId, paused, language) {
+    await this.repairAndSyncConversationBeforeWrite(conversationId);
     return this.orchestration.setGoalPaused(conversationId, paused, language);
   }
   async clearGoal(conversationId, language) {
+    await this.repairAndSyncConversationBeforeWrite(conversationId);
     return this.orchestration.clearGoal(conversationId, language);
   }
   async startContextCompression(input) {
+    await this.repairAndSyncConversationBeforeWrite(input.conversationId);
     return this.contextCompression.start(input);
   }
   async cancelRun(conversationId, runId) {
@@ -32659,6 +33291,117 @@ var ConversationService = class {
     }
     return this.cancelRun(conversationId, runId);
   }
+  async repairStaleConversationRuns(conversationId) {
+    const compressionRepaired = await this.contextCompression.repairDetachedRunningCompressions(conversationId).catch((error) => {
+      void this.logger.warn("conversation_stale_compression_repair_failed", {
+        conversation_id: conversationId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    });
+    const result = await this.runLifecycle.repairStaleConversationRuns(conversationId).catch((error) => {
+      void this.logger.warn("conversation_stale_run_repair_failed", {
+        conversation_id: conversationId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    });
+    const hasPendingRepair = result?.pending === true;
+    const repaired = compressionRepaired || result?.repaired === true || result?.shouldDrainQueue === true;
+    const shouldDrainQueue = compressionRepaired || result?.shouldDrainQueue || await this.conversationQueueNeedsDrain(conversationId);
+    if (!shouldDrainQueue) {
+      if (hasPendingRepair) {
+        this.scheduleStaleRunRepairRetry(conversationId);
+      } else {
+        this.clearStaleRunRepairRetry(conversationId);
+      }
+      return repaired;
+    }
+    if (hasPendingRepair) {
+      this.scheduleStaleRunRepairRetry(conversationId);
+    } else {
+      this.clearStaleRunRepairRetry(conversationId);
+    }
+    void this.orchestration.startNextQueuedRun(conversationId).catch((error) => {
+      void this.logger.warn("conversation_queue_drain_failed", {
+        conversation_id: conversationId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+    return true;
+  }
+  async repairAndSyncConversationBeforeWrite(conversationId) {
+    await this.repairAndSyncConversation(conversationId, "conversation_write");
+  }
+  async repairAndSyncConversation(conversationId, source) {
+    await this.repairStaleConversationRuns(conversationId);
+    await this.syncHermesConversationMessagesBestEffort(conversationId, source);
+    await this.repairStaleConversationRuns(conversationId);
+  }
+  async syncHermesConversationMessagesBestEffort(conversationId, source) {
+    await this.syncHermesConversationMessages(conversationId).catch(
+      (error) => {
+        void this.logger.warn("hermes_conversation_message_sync_failed", {
+          source,
+          conversation_id: conversationId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    );
+  }
+  async conversationQueueNeedsDrain(conversationId) {
+    const snapshot = await this.store.readSnapshot(conversationId).catch(() => null);
+    return Boolean(
+      snapshot && hasQueuedRuns(snapshot) && !hasRunningRuns(snapshot)
+    );
+  }
+  async repairStaleConversationSummaries(summaries, reread) {
+    let repaired = false;
+    for (const summary of summaries) {
+      if (!conversationSummaryNeedsStaleRunRepair(summary)) {
+        continue;
+      }
+      await this.repairStaleConversationRuns(summary.id);
+      repaired = true;
+    }
+    if (!repaired) {
+      return summaries;
+    }
+    return reread();
+  }
+  async repairStaleConversationListPage(page, reread) {
+    let repaired = false;
+    for (const summary of page.conversations) {
+      if (!conversationSummaryNeedsStaleRunRepair(summary)) {
+        continue;
+      }
+      await this.repairStaleConversationRuns(summary.id);
+      repaired = true;
+    }
+    return repaired ? reread() : page;
+  }
+  scheduleStaleRunRepairRetry(conversationId) {
+    if (this.staleRunRepairRetryTimers.has(conversationId)) {
+      return;
+    }
+    const attempt = this.staleRunRepairRetryAttempts.get(conversationId) ?? 0;
+    const delayMs = STALE_RUN_REPAIR_RETRY_DELAYS_MS[Math.min(attempt, STALE_RUN_REPAIR_RETRY_DELAYS_MS.length - 1)];
+    this.staleRunRepairRetryAttempts.set(conversationId, attempt + 1);
+    const timer = setTimeout(() => {
+      this.staleRunRepairRetryTimers.delete(conversationId);
+      void this.repairStaleConversationRuns(conversationId);
+    }, delayMs);
+    timer.unref?.();
+    this.staleRunRepairRetryTimers.set(conversationId, timer);
+  }
+  clearStaleRunRepairRetry(conversationId) {
+    this.staleRunRepairRetryAttempts.delete(conversationId);
+    const timer = this.staleRunRepairRetryTimers.get(conversationId);
+    if (timer) {
+      clearTimeout(timer);
+      this.staleRunRepairRetryTimers.delete(conversationId);
+    }
+  }
   async guideQueuedRun(conversationId, runId) {
     return this.orchestration.guideQueuedRun(conversationId, runId);
   }
@@ -33636,6 +34379,9 @@ function liveActivityPhaseForEvent(event, run, contextOperation) {
   if (type === "context_compression.timed_out") {
     return "context_compression_timed_out";
   }
+  if (type === "context_compression.cancelled" || type === "context_compression.canceled") {
+    return "cancelled";
+  }
   if (type === "run.completed") {
     return "completed";
   }
@@ -33771,6 +34517,13 @@ function readInteger4(value, key) {
   }
   return Math.max(0, Math.trunc(parsed));
 }
+function conversationSummaryNeedsStaleRunRepair(summary) {
+  const eventStream = summary.event_stream;
+  if (!eventStream) {
+    return false;
+  }
+  return eventStream.has_active_runs || eventStream.reason === "context_compression" || eventStream.reason === "active_run" || eventStream.reason === "queued_run" || eventStream.reason === "unknown";
+}
 function approvalRestartText(language, zh, en) {
   return language === "en" ? en : zh;
 }

package/dist/cli/index.js

@@ -55,7 +55,7 @@ import {
   stopDaemonProcess,
   summarizeUsageProbeEnsure,
   translate
-} from "../chunk-VVHNBT4E.js";
+} from "../chunk-QT55LT5X.js";
 
 // src/cli/index.ts
 import { Command } from "commander";

package/dist/http/app.d.ts

@@ -626,6 +626,8 @@ declare class ConversationService {
     private readonly runLifecycle;
     private hermesSessionSyncPromise;
     private cronDeliverySyncPromise;
+    private readonly staleRunRepairRetryAttempts;
+    private readonly staleRunRepairRetryTimers;
     constructor(paths: RuntimePaths, logger: FileLogger);
     private withConversationLock;
     private restoreArchivedConversationForUserContinuationLocked;
@@ -753,6 +755,15 @@ declare class ConversationService {
     startContextCompression(input: StartContextCompressionInput): Promise<ContextCompressionResult>;
     cancelRun(conversationId: string, runId: string): Promise<CancelRunResult>;
     cancelRunById(runId: string): Promise<CancelRunResult>;
+    private repairStaleConversationRuns;
+    private repairAndSyncConversationBeforeWrite;
+    private repairAndSyncConversation;
+    private syncHermesConversationMessagesBestEffort;
+    private conversationQueueNeedsDrain;
+    private repairStaleConversationSummaries;
+    private repairStaleConversationListPage;
+    private scheduleStaleRunRepairRetry;
+    private clearStaleRunRepairRetry;
     guideQueuedRun(conversationId: string, runId: string): Promise<QueuedRunActionResult>;
     cancelQueuedRun(conversationId: string, runId: string): Promise<QueuedRunActionResult>;
     resolveApproval(input: {

package/dist/http/app.js

@@ -1,6 +1,6 @@
 import {
   createApp
-} from "../chunk-VVHNBT4E.js";
+} from "../chunk-QT55LT5X.js";
 export {
   createApp
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hermespilot/link",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "private": false,
   "description": "Hermes Link companion service and CLI for connecting hermes-agent through HermesPilot",
   "license": "MIT",