@hermespilot/link 0.8.5-beta.0 → 0.8.5

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

@@ -7721,7 +7721,7 @@ function isConversationMissingError(error) {
 }
 
 // src/constants.ts
-var LINK_VERSION = "0.8.5-beta.0";
+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(
@@ -18253,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,
@@ -18467,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 } : {}
     };
@@ -20248,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);
@@ -21736,6 +21786,7 @@ async function syncHermesConversationMessages(paths, logger, input) {
   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({
@@ -21747,6 +21798,7 @@ async function syncHermesConversationMessages(paths, logger, input) {
           updatedAt: isoFromHermesTime(profile.candidate.session.last_active) ?? nextManifest2.updated_at
         });
       }
+      lineageChanged = !manifestEquivalent(currentManifest, nextManifest2);
       if (duplicateCleanup.removedCount > 0) {
         nextManifest2 = {
           ...nextManifest2,
@@ -21757,13 +21809,30 @@ async function syncHermesConversationMessages(paths, logger, input) {
     if (duplicateCleanup.removedCount > 0) {
       await store.writeSnapshot(input.conversationId, snapshot);
     }
-    if (nextManifest2 && currentManifest && (duplicateCleanup.removedCount > 0 || !manifestEquivalent(currentManifest, nextManifest2))) {
+    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;
   }
@@ -22194,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
@@ -22209,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) {
@@ -22281,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
   );
@@ -22292,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,
@@ -22419,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;
 }
@@ -22777,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();
@@ -29747,16 +29857,36 @@ ${resolved}` : resolved;
     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) && !this.deps.activeRunControllers.has(run.id)
+      (run) => isRunningAutomaticContextCompression(run)
     ) ?? [];
     let repaired = false;
     for (const run of candidates) {
-      if (this.deps.activeRunControllers.has(run.id)) {
-        continue;
-      }
       const previousSessionId = run.context_compression?.previous_session_id?.trim() || run.hermes_session_id;
       const nextSessionId = await readHermesCompressionTip(
         previousSessionId,
@@ -29775,11 +29905,177 @@ ${resolved}` : resolved;
       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;
@@ -29835,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()) {
@@ -31643,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;
@@ -31665,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";
 }
@@ -31769,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 ?? "");
 }
@@ -31889,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;
@@ -31933,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);
@@ -32510,19 +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)
-          });
-        }
-      );
-    }
-    if (!options.beforeMessageId) {
-      await this.runLifecycle.repairStaleAutomaticContextCompression(
-        conversationId
-      );
+      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);
   }
@@ -32548,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
@@ -32667,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);
@@ -32823,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) {
@@ -32860,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) {
@@ -32897,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);
   }
@@ -33874,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";
   }
@@ -34009,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-JJBIYFGY.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-JJBIYFGY.js";
+} from "../chunk-QT55LT5X.js";
 export {
   createApp
 };

package/package.json

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