@gmickel/gno 2.5.1 → 2.7.0

package/src/serve/embed-scheduler.ts

@@ -9,6 +9,7 @@ import type { Database } from "bun:sqlite";
 
 import type { EmbeddingPort } from "../llm/types";
 import type { VectorIndexPort } from "../store/vector";
+import type { BackgroundIssue } from "./status-model";
 
 import { embedBacklog } from "../embed";
 import {
@@ -24,6 +25,15 @@ import { createVectorStatsPort } from "../store/vector";
 const DEBOUNCE_MS = 30_000; // 30 seconds
 const MAX_WAIT_MS = 300_000; // 5 minutes
 const BATCH_SIZE = 32;
+/** Consecutive failed passes after which automatic retries stop (parked). */
+export const MAX_FAILED_PASSES = 5;
+/** A pass running longer than this is reported as overrunning. */
+export const PASS_OVERRUN_MS = 15 * 60_000;
+
+/** Delay before the automatic retry that follows `failures` failed passes. */
+export function failedPassRetryDelayMs(failures: number): number {
+  return DEBOUNCE_MS * 2 ** Math.max(0, failures - 1);
+}
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -35,6 +45,12 @@ export interface EmbedSchedulerState {
   nextRunAt?: number;
   lastRunAt?: number;
   lastResult?: EmbedResult;
+  /** Start of the pass in flight. */
+  runningSince?: number;
+  /** Failed passes since the last clean pass (0 when healthy). */
+  consecutiveFailures: number;
+  /** Automatic retries stopped; chunks stay pending for new work or `gno embed`. */
+  parked: boolean;
 }
 
 export interface EmbedResult {
@@ -52,6 +68,47 @@ export interface EmbedSchedulerDeps {
   getModelUri: () => string;
   onEmbedded?: (result: EmbedResult) => void;
   embedBacklogFn?: typeof embedBacklog;
+  /**
+   * Shared writer lease for one page of background writes; null when another
+   * writer holds it, which defers the rest of the pass instead of waiting.
+   */
+  acquireWriteLease?: () => Promise<(() => Promise<void>) | null>;
+}
+
+/** Project scheduler state onto status issues; empty while healthy. */
+export function embedSchedulerIssues(
+  state: EmbedSchedulerState,
+  now = Date.now()
+): BackgroundIssue[] {
+  const issues: BackgroundIssue[] = [];
+  if (state.parked || state.consecutiveFailures > 0) {
+    issues.push({
+      job: "embed",
+      state: state.parked ? "parked" : "failing",
+      consecutiveFailures: state.consecutiveFailures,
+      runningSeconds: null,
+    });
+  }
+  if (
+    state.runningSince !== undefined &&
+    now - state.runningSince > PASS_OVERRUN_MS
+  ) {
+    issues.push({
+      job: "embed",
+      state: "overrunning",
+      consecutiveFailures: state.consecutiveFailures,
+      runningSeconds: Math.floor((now - state.runningSince) / 1000),
+    });
+  }
+  return issues;
+}
+
+interface PassOutcome {
+  result: EmbedResult;
+  /** Present when the pass failed; the message is logged once per retry step. */
+  failure?: string;
+  /** Another writer held the lease; the rest of the backlog waits for a rerun. */
+  deferred?: boolean;
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -86,6 +143,7 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
     getModelUri,
     onEmbedded,
     embedBacklogFn = embedBacklog,
+    acquireWriteLease,
   } = deps;
 
   // State
@@ -99,6 +157,9 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
   let currentRun: Promise<EmbedResult | null> | null = null;
   let lastRunAt: number | null = null;
   let lastResult: EmbedResult | null = null;
+  let runningSince: number | null = null;
+  let consecutiveFailures = 0;
+  let parked = false;
   const controller = new AbortController();
 
   const stats = createVectorStatsPort(db);
@@ -110,14 +171,14 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
    * 2. Filtering by docId would require joining through documents table
    * 3. Simpler to just embed all backlog when triggered
    */
-  async function runEmbed(): Promise<EmbedResult> {
+  async function runEmbed(): Promise<PassOutcome> {
     // Resolve dependencies at execution time (survives context reloads)
     const embedPort = getEmbedPort();
     const vectorIndex = getVectorIndex();
     const modelUri = getModelUri();
 
     if (!embedPort || !vectorIndex) {
-      return { embedded: 0, errors: 0 };
+      return { result: { embedded: 0, errors: 0 } };
     }
 
     let result: Awaited<ReturnType<typeof embedBacklogFn>>;
@@ -130,6 +191,7 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
             vectorIndex,
             modelUri,
             batchSize: BATCH_SIZE,
+            acquireWriteTurn: acquireWriteLease,
             identityStillCurrent: () =>
               getEmbedPort() === embedPort &&
               getVectorIndex() === vectorIndex &&
@@ -138,14 +200,21 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
         )
       );
     } catch (cause) {
-      if (controller.signal.aborted) return { embedded: 0, errors: 0 };
-      throw cause;
+      if (controller.signal.aborted)
+        return { result: { embedded: 0, errors: 0 } };
+      // An inference deadline or worker exit aborts the whole pass. It is a
+      // failed pass like any other, never a silently dropped rejection.
+      return {
+        result: { embedded: 0, errors: 0 },
+        failure: cause instanceof Error ? cause.message : String(cause),
+      };
     }
 
     if (!result.ok) {
-      needsRerun = true;
-      console.error("[embed-scheduler] Embed failed:", result.error.message);
-      return { embedded: 0, errors: 0 };
+      return {
+        result: { embedded: 0, errors: 0 },
+        failure: result.error.message,
+      };
     }
     if (
       getEmbedPort() !== embedPort ||
@@ -153,21 +222,42 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
       getModelUri() !== modelUri
     )
       needsRerun = true;
-    if ((result.value.contentionErrors ?? 0) > 0 || result.value.errors > 0) {
-      // Provider failures and contended checkpoints remain durably pending.
+    if (result.value.deferred) needsRerun = true;
+    if (result.value.embedded > 0) onEmbedded?.(result.value);
+    const contended = result.value.contentionErrors ?? 0;
+    const deferred = result.value.deferred === true;
+    // Provider failures and contended checkpoints remain durably pending.
+    return result.value.errors > 0 || contended > 0
+      ? {
+          result: result.value,
+          deferred,
+          failure: `${result.value.errors} embedding errors, ${contended} contended writes`,
+        }
+      : { result: result.value, deferred };
+  }
+
+  /** Count a failed pass and schedule its bounded retry, logging each step once. */
+  function recordFailure(message: string): void {
+    consecutiveFailures += 1;
+    if (parked) return;
+    if (consecutiveFailures >= MAX_FAILED_PASSES) {
+      parked = true;
       console.error(
-        `[embed-scheduler] ${result.value.errors} embedding errors, ${result.value.contentionErrors ?? 0} contended writes; rescheduling`
+        `[embed-scheduler] Embed pass failed ${consecutiveFailures} times (${message}); automatic retries parked. Pending chunks stay queued for new changes or \`gno embed\`.`
       );
-      needsRerun = true;
+      return;
     }
-    if (result.value.embedded > 0) onEmbedded?.(result.value);
-    return result.value;
+    const delay = failedPassRetryDelayMs(consecutiveFailures);
+    console.error(
+      `[embed-scheduler] Embed pass failed (${consecutiveFailures}/${MAX_FAILED_PASSES}): ${message}; retrying in ${Math.round(delay / 1000)}s`
+    );
+    scheduleRun(delay);
   }
 
   /**
    * Schedule or reschedule the debounced embed run.
    */
-  function scheduleRun(): void {
+  function scheduleRun(retryDelay?: number): void {
     if (disposed) {
       return;
     }
@@ -180,7 +270,7 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
 
     // Calculate delay
     const now = Date.now();
-    let delay = DEBOUNCE_MS;
+    let delay = retryDelay ?? DEBOUNCE_MS;
 
     // Check max-wait
     if (firstPendingAt !== null) {
@@ -226,17 +316,38 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
       pendingCount = 0;
       firstPendingAt = null;
 
-      let result: EmbedResult;
+      runningSince = Date.now();
+      let outcome: PassOutcome;
       try {
-        result = await runEmbed();
+        outcome = await runEmbed();
         lastRunAt = Date.now();
-        lastResult = result;
+        lastResult = outcome.result;
       } finally {
         running = false;
+        runningSince = null;
       }
+      const result = outcome.result;
 
-      // Check if we need to rerun (notifications arrived while running)
       // Must be AFTER running=false so scheduleRun() actually schedules
+      if (outcome.failure !== undefined && !disposed) {
+        // A failed pass never reruns immediately: the bounded retry covers work
+        // that arrived meanwhile, and once parked only fresh work earns a pass.
+        needsRerun = false;
+        recordFailure(outcome.failure);
+        // Parked stops retries of failed work, never a lease-deferred remainder.
+        if (parked && (pendingCount > 0 || outcome.deferred)) {
+          firstPendingAt ??= Date.now();
+          scheduleRun();
+        }
+        return result;
+      }
+      // Only a pass that reached the end of the backlog cleanly clears failures.
+      if (outcome.failure === undefined && !outcome.deferred) {
+        consecutiveFailures = 0;
+        parked = false;
+      }
+
+      // Check if we need to rerun (notifications arrived while running)
       if ((needsRerun || pendingCount > 0) && !disposed) {
         needsRerun = false;
         // Set firstPendingAt if we have pending work
@@ -313,7 +424,10 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
       const state: EmbedSchedulerState = {
         pendingDocCount: pendingCount,
         running,
+        consecutiveFailures,
+        parked,
       };
+      if (runningSince !== null) state.runningSince = runningSince;
 
       // Use accurate nextRunAt from timer scheduling
       if (nextRunAt !== null) {

package/src/serve/host-path-redaction.ts

@@ -0,0 +1,79 @@
+/**
+ * REST boundary for host paths: a caller the request-locality rule judges
+ * remote never receives an `absPath` field from any `/api/*` JSON response.
+ * Same-host callers (the loopback Web UI) keep them for Reveal and
+ * "Open original". Routes that stream original source bytes are exempt:
+ * their body is the owner's file, not an API envelope.
+ */
+
+import { withoutHostPaths } from "../core/host-paths";
+import {
+  isLocalClientRequest,
+  type RequestPeerServer,
+} from "./request-locality";
+
+const HOST_PATH_KEY = '"absPath"';
+const SOURCE_BYTE_ROUTES = new Set(["/api/doc-asset"]);
+
+type RouteHandler = (
+  req: Request,
+  server: RequestPeerServer
+) => Response | Promise<Response>;
+
+/** The JSON response with every `absPath` field removed. */
+export async function redactResponseHostPaths(
+  response: Response
+): Promise<Response> {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("application/json") || response.body === null) {
+    return response;
+  }
+  const text = await response.text();
+  const body = text.includes(HOST_PATH_KEY)
+    ? JSON.stringify(withoutHostPaths(JSON.parse(text) as unknown))
+    : text;
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}
+
+const redacting =
+  (handler: RouteHandler): RouteHandler =>
+  async (req, server) => {
+    const response = await handler(req, server);
+    return isLocalClientRequest(req, server)
+      ? response
+      : redactResponseHostPaths(response);
+  };
+
+const isMethodTable = (route: unknown): route is Record<string, unknown> =>
+  route !== null &&
+  typeof route === "object" &&
+  Object.getPrototypeOf(route) === Object.prototype;
+
+/** Wrap every `/api/*` handler in the remote host-path redaction. */
+export function withRemoteHostPathRedaction<T extends Record<string, unknown>>(
+  routes: T
+): T {
+  const wrapped: Record<string, unknown> = { ...routes };
+  for (const [path, route] of Object.entries(routes)) {
+    if (!path.startsWith("/api/") || SOURCE_BYTE_ROUTES.has(path)) continue;
+    if (typeof route === "function") {
+      wrapped[path] = redacting(route as RouteHandler);
+    } else if (isMethodTable(route)) {
+      wrapped[path] = Object.fromEntries(
+        Object.entries(route).map(([method, handler]) => [
+          method,
+          typeof handler === "function"
+            ? redacting(handler as RouteHandler)
+            : handler,
+        ])
+      );
+    }
+  }
+  return wrapped as T;
+}

package/src/serve/public/app.tsx

@@ -49,6 +49,7 @@ const Ask = lazy(() => import("./pages/Ask"));
 const GraphView = lazy(() => import("./pages/GraphView"));
 const CompiledContext = lazy(() => import("./pages/CompiledContext"));
 const TraceHistory = lazy(() => import("./pages/TraceHistory"));
+const Sessions = lazy(() => import("./pages/Sessions"));
 
 type Route =
   | "/"
@@ -61,7 +62,8 @@ type Route =
   | "/graph"
   | "/connectors"
   | "/context/compiled"
-  | "/traces";
+  | "/traces"
+  | "/sessions";
 type Navigate = (to: string | number) => void;
 
 interface RoutePageProps {
@@ -80,6 +82,7 @@ const routes: Record<Route, React.ComponentType<RoutePageProps>> = {
   "/ask": Ask,
   "/graph": GraphView,
   "/traces": TraceHistory,
+  "/sessions": Sessions,
   "/context/compiled": CompiledContext,
 };
 

package/src/serve/public/components/CaptureModal.tsx

@@ -26,6 +26,13 @@ import {
   resolveNotePreset,
 } from "../../../core/note-presets";
 import { apiFetch } from "../hooks/use-api";
+import {
+  clearRequestIntent,
+  type RequestIntent,
+  requestIdForIntent,
+} from "../lib/request-intent";
+
+const CAPTURE_INTENT_KEY = "gno:capture-intent";
 import { getActiveWikiLinkQuery } from "../lib/wiki-link";
 import { IndexingProgress } from "./IndexingProgress";
 import { TagInput } from "./TagInput";
@@ -169,6 +176,7 @@ export function CaptureModal({
   const [wikiLinkPosition, setWikiLinkPosition] = useState({ x: 24, y: 24 });
   const [wikiLinkActiveIndex, setWikiLinkActiveIndex] = useState(-1);
   const contentRef = useRef<HTMLTextAreaElement | null>(null);
+  const captureIntentRef = useRef<RequestIntent | null>(null);
 
   // Submission state
   const [state, setState] = useState<ModalState>("form");
@@ -311,19 +319,28 @@ export function CaptureModal({
         ? selectedPresetId
         : undefined;
 
+    const payload = {
+      collection,
+      title,
+      folderPath: defaultFolderPath || undefined,
+      content: presetOnly ? undefined : content,
+      presetId: submitPresetId,
+      collisionPolicy: "create_with_suffix",
+      source,
+      ...(tags.length > 0 && { tags }),
+    };
     const { data, error: err } = await apiFetch<CaptureResponse>(
       "/api/capture",
       {
         method: "POST",
         body: JSON.stringify({
-          collection,
-          title,
-          folderPath: defaultFolderPath || undefined,
-          content: presetOnly ? undefined : content,
-          presetId: submitPresetId,
-          collisionPolicy: "create_with_suffix",
-          source,
-          ...(tags.length > 0 && { tags }),
+          ...payload,
+          // A retry of this exact capture replays instead of adding a suffix copy.
+          requestId: requestIdForIntent(
+            captureIntentRef,
+            JSON.stringify(payload),
+            CAPTURE_INTENT_KEY
+          ),
         }),
       }
     );
@@ -335,6 +352,7 @@ export function CaptureModal({
     }
 
     if (data) {
+      clearRequestIntent(captureIntentRef, CAPTURE_INTENT_KEY);
       // Save last used collection
       localStorage.setItem(STORAGE_KEY, collection);