@gmickel/gno 2.8.5 → 2.9.1

package/README.md

@@ -139,7 +139,7 @@ See the [guide](docs/COMPILED-CONTEXT.md).
 
 <!-- public-truth:current-version -->
 
-> Current source version: **v2.8.5**. See [CHANGELOG.md](./CHANGELOG.md).
+> Current source version: **v2.9.1**. See [CHANGELOG.md](./CHANGELOG.md).
 
 <!-- /public-truth -->
 

package/browser-extension/artifacts/gno-browser-clipper-v2.9.1.zip.sha256

@@ -0,0 +1 @@
+f58e51eea9d0b35a61ef55574882c4be8002ed2fdc29966a3cd1bd7c84350e3c  gno-browser-clipper-v2.9.1.zip

package/browser-extension/dist/manifest.json

@@ -21,5 +21,5 @@
   "content_security_policy": {
     "extension_pages": "script-src 'self'; object-src 'none'; connect-src http://127.0.0.1:*"
   },
-  "version": "2.8.5"
+  "version": "2.9.1"
 }

package/bunfig.toml

@@ -2,6 +2,6 @@
 plugins = ["bun-plugin-tailwind"]
 
 [test]
-preload = ["./test/preload/happy-dom.ts"]
+preload = ["./test/preload/happy-dom.ts", "./test/preload/env-guard.ts"]
 # Frozen evidence and local experiments are not the executable regression suite.
 pathIgnorePatterns = [".flow/artifacts/**", "notes/**"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "2.8.5",
+  "version": "2.9.1",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/src/cli/commands/shared.ts

@@ -20,6 +20,7 @@ import {
   loadConfig,
   writeConfigWarningsToStderr,
 } from "../../config";
+import { tracePhase } from "../../core/phase-trace";
 import { BUDGET_ERROR_CODES } from "../../ingestion/file-processor";
 import { SqliteAdapter } from "../../store/sqlite/adapter";
 import { assertCliSessionBinding } from "../session-binding";
@@ -63,6 +64,7 @@ export interface InitStoreOptions {
 export async function initStore(
   options: InitStoreOptions = {}
 ): Promise<InitStoreResult> {
+  tracePhase("store: init");
   // Check if initialized
   const initialized = await isInitialized(options.configPath);
   if (!initialized) {
@@ -119,11 +121,13 @@ export async function initStore(
   // Set configPath for status output
   store.setConfigPath(actualConfigPath);
 
+  tracePhase("store: opening index");
   const openResult = await store.open(
     dbPath,
     config.ftsTokenizer,
     config.busyTimeoutMs
   );
+  tracePhase("store: index open");
   if (!openResult.ok) {
     return { ok: false, error: openResult.error.message };
   }
@@ -139,6 +143,7 @@ export async function initStore(
     return { ok: false, error: syncCollResult.error.message };
   }
 
+  tracePhase("store: collections synced");
   // Sync contexts from config to DB
   const syncCtxResult = await store.syncContexts(config.contexts ?? []);
   if (!syncCtxResult.ok) {
@@ -146,6 +151,7 @@ export async function initStore(
     return { ok: false, error: syncCtxResult.error.message };
   }
 
+  tracePhase("store: contexts synced");
   return { ok: true, store, config, collections, actualConfigPath };
 }
 

package/src/converters/adapters/markitdownTs/adapter.ts

@@ -20,20 +20,11 @@ import {
 } from "../../errors";
 import { ADAPTER_VERSIONS } from "../../versions";
 import { hasPrefix, isPasswordProtectedXlsx } from "../shared/ooxml-protection";
+import { MARKITDOWN_CONVERTER_ID, markitdownCanHandle } from "./match";
 
-const CONVERTER_ID = "adapter/markitdown-ts" as const;
+const CONVERTER_ID = MARKITDOWN_CONVERTER_ID;
 const CONVERTER_VERSION = ADAPTER_VERSIONS["markitdown-ts"];
 
-/** Supported extensions for this adapter */
-const SUPPORTED_EXTENSIONS = [".pdf", ".docx", ".xlsx"];
-
-/** Supported MIME types */
-const SUPPORTED_MIMES = [
-  "application/pdf",
-  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-];
-
 const PDF_SIGNATURE = new Uint8Array([0x25, 0x50, 0x44, 0x46, 0x2d]);
 const PDF_TRAILER_SCAN_BYTES = 2048;
 const MAX_MESSAGE_LENGTH = 200;
@@ -114,9 +105,7 @@ export const markitdownAdapter: Converter = {
   id: CONVERTER_ID,
   version: CONVERTER_VERSION,
 
-  canHandle(mime: string, ext: string): boolean {
-    return SUPPORTED_EXTENSIONS.includes(ext) || SUPPORTED_MIMES.includes(mime);
-  },
+  canHandle: markitdownCanHandle,
 
   async convert(input: ConvertInput): Promise<ConvertResult> {
     // 1. Check size limit (defense in depth; EPIC 5 does stat-based pre-check)

package/src/converters/adapters/markitdownTs/match.ts

@@ -0,0 +1,20 @@
+/**
+ * Routing for the markitdown-ts adapter, kept apart from the adapter so the
+ * registry can route files without loading pdf.js and the Office parsers.
+ */
+
+export const MARKITDOWN_CONVERTER_ID = "adapter/markitdown-ts" as const;
+
+/** Supported extensions for this adapter */
+const SUPPORTED_EXTENSIONS = [".pdf", ".docx", ".xlsx"];
+
+/** Supported MIME types */
+const SUPPORTED_MIMES = [
+  "application/pdf",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+];
+
+export function markitdownCanHandle(mime: string, ext: string): boolean {
+  return SUPPORTED_EXTENSIONS.includes(ext) || SUPPORTED_MIMES.includes(mime);
+}

package/src/converters/adapters/officeparser/adapter.ts

@@ -14,14 +14,11 @@ import { parseOffice } from "../../../../vendor/converters/officeparser";
 import { adapterError, corruptError, tooLargeError } from "../../errors";
 import { basenameWithoutExt } from "../../path";
 import { ADAPTER_VERSIONS } from "../../versions";
+import { OFFICEPARSER_CONVERTER_ID, officeparserCanHandle } from "./match";
 
-const CONVERTER_ID = "adapter/officeparser" as const;
+const CONVERTER_ID = OFFICEPARSER_CONVERTER_ID;
 const CONVERTER_VERSION = ADAPTER_VERSIONS.officeparser;
 
-/** Supported MIME type */
-const PPTX_MIME =
-  "application/vnd.openxmlformats-officedocument.presentationml.presentation";
-
 /**
  * Control character pattern built dynamically to avoid lint issues.
  * Matches U+0000-U+001F and U+007F (all ASCII control chars).
@@ -62,9 +59,7 @@ export const officeparserAdapter: Converter = {
   id: CONVERTER_ID,
   version: CONVERTER_VERSION,
 
-  canHandle(mime: string, ext: string): boolean {
-    return ext === ".pptx" || mime === PPTX_MIME;
-  },
+  canHandle: officeparserCanHandle,
 
   async convert(input: ConvertInput): Promise<ConvertResult> {
     // Size check (defense in depth; EPIC 5 does stat-based pre-check)

package/src/converters/adapters/officeparser/match.ts

@@ -0,0 +1,13 @@
+/**
+ * Routing for the officeparser adapter, kept apart from the adapter so the
+ * registry can route files without loading the parser.
+ */
+
+export const OFFICEPARSER_CONVERTER_ID = "adapter/officeparser" as const;
+
+const PPTX_MIME =
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+
+export function officeparserCanHandle(mime: string, ext: string): boolean {
+  return ext === ".pptx" || mime === PPTX_MIME;
+}

package/src/converters/registry.ts

@@ -5,12 +5,22 @@
 
 import type {
   Converter,
+  ConverterId,
   ConvertInput,
   ConvertResult,
   RecordAdapter,
 } from "./types";
 
+import {
+  MARKITDOWN_CONVERTER_ID,
+  markitdownCanHandle,
+} from "./adapters/markitdownTs/match";
+import {
+  OFFICEPARSER_CONVERTER_ID,
+  officeparserCanHandle,
+} from "./adapters/officeparser/match";
 import { adapterError, unsupportedError } from "./errors";
+import { ADAPTER_VERSIONS } from "./versions";
 
 export class ConverterRegistry {
   private readonly converters: Converter[] = [];
@@ -71,38 +81,56 @@ export class ConverterRegistry {
   }
 }
 
+/** Identity and routing of an adapter whose module loads on first use. */
+export interface LazyAdapterSpec {
+  id: ConverterId;
+  version: string;
+  canHandle: Converter["canHandle"];
+}
+
 /**
- * Load an adapter module; if it cannot load in this runtime, stand in a
- * converter that fails its file types with ADAPTER_FAILURE and the reason.
+ * An adapter that loads its module on its first conversion. Routing and
+ * identity come from the spec, so selecting a converter or a record adapter
+ * never loads the parser: the PDF/Office parsers took 9-11 s to load on a
+ * cold Windows runner, inside every `gno update` (fn-201). If the module
+ * cannot load in this runtime (pdf.js without its native canvas binding in a
+ * standalone executable), its file types fail with ADAPTER_FAILURE and the
+ * reason, and other file types are unaffected.
  */
-export async function loadAdapter(
-  load: () => Promise<Converter>,
-  id: string,
-  extensions: readonly string[],
-  mimes: readonly string[]
-): Promise<Converter> {
-  try {
-    return await load();
-  } catch (cause) {
-    const reason = cause instanceof Error ? cause.message : String(cause);
-    return {
-      id,
-      version: "unavailable",
-      // Same matching as the real adapter, so a sniffed MIME without an
-      // extension still reports ADAPTER_FAILURE, not UNSUPPORTED.
-      canHandle: (mime, ext) =>
-        extensions.includes(ext) || mimes.includes(mime),
-      convert: (input) =>
-        Promise.resolve({
-          ok: false,
-          error: adapterError(
-            input,
-            id,
-            `${id} is unavailable in this build: ${reason}`
-          ),
-        }),
-    };
-  }
+export function lazyAdapter(
+  spec: LazyAdapterSpec,
+  load: () => Promise<Converter>
+): Converter {
+  let loaded: Promise<Converter> | undefined;
+  return {
+    id: spec.id,
+    version: spec.version,
+    canHandle: spec.canHandle,
+    async convert(input) {
+      loaded ??= load().catch((cause: unknown) =>
+        unavailableAdapter(
+          spec,
+          cause instanceof Error ? cause.message : String(cause)
+        )
+      );
+      return (await loaded).convert(input);
+    },
+  };
+}
+
+function unavailableAdapter(spec: LazyAdapterSpec, reason: string): Converter {
+  return {
+    ...spec,
+    convert: (input) =>
+      Promise.resolve({
+        ok: false,
+        error: adapterError(
+          input,
+          spec.id,
+          `${spec.id} is unavailable in this build: ${reason}`
+        ),
+      }),
+  };
 }
 
 /**
@@ -121,27 +149,23 @@ export async function createDefaultRegistry(): Promise<ConverterRegistry> {
   const { markdownConverter } = await import("./native/markdown");
   const { plaintextConverter } = await import("./native/plaintext");
   const { xlsxAdapter } = await import("./adapters/xlsx/adapter");
-  // The PDF/Office adapters load pdf.js, which cannot initialize where its
-  // native canvas binding is missing (a standalone compiled executable). A
-  // failed adapter only fails its own file types.
-  const markitdownAdapter = await loadAdapter(
+  const markitdownAdapter = lazyAdapter(
+    {
+      id: MARKITDOWN_CONVERTER_ID,
+      version: ADAPTER_VERSIONS["markitdown-ts"],
+      canHandle: markitdownCanHandle,
+    },
     async () =>
-      (await import("./adapters/markitdownTs/adapter")).markitdownAdapter,
-    "adapter/markitdown-ts",
-    [".pdf", ".docx"],
-    [
-      "application/pdf",
-      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    ]
+      (await import("./adapters/markitdownTs/adapter")).markitdownAdapter
   );
-  const officeparserAdapter = await loadAdapter(
+  const officeparserAdapter = lazyAdapter(
+    {
+      id: OFFICEPARSER_CONVERTER_ID,
+      version: ADAPTER_VERSIONS.officeparser,
+      canHandle: officeparserCanHandle,
+    },
     async () =>
-      (await import("./adapters/officeparser/adapter")).officeparserAdapter,
-    "adapter/officeparser",
-    [".pptx"],
-    [
-      "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    ]
+      (await import("./adapters/officeparser/adapter")).officeparserAdapter
   );
   const { jsonlAdapter } = await import("./adapters/jsonl/adapter");
   const { transcriptAdapter } = await import("./adapters/transcript/adapter");

package/src/core/phase-trace.ts

@@ -0,0 +1,34 @@
+/**
+ * Opt-in startup phase trace for diagnosing stalled CLI runs.
+ *
+ * With `GNO_PHASE_TRACE=1`, each call writes one line to stderr:
+ * `gno-phase <ms since process start> <pid> <label>`. The write is
+ * synchronous so a line reaches the pipe before a later blocking call (a
+ * SQLite busy wait, a native load) can stall the process; the last line a
+ * killed process printed names the phase it stalled in.
+ *
+ * @module src/core/phase-trace
+ */
+
+// node:fs writeSync: Bun has no synchronous stderr write; process.stderr.write
+// to a pipe can still be queued when the event loop blocks.
+import { writeSync } from "node:fs";
+
+export const PHASE_TRACE_ENV = "GNO_PHASE_TRACE";
+
+const STDERR_FD = 2;
+
+const enabled = process.env[PHASE_TRACE_ENV] === "1";
+
+/** Record that the process reached `label` (no-op unless tracing is on). */
+export function tracePhase(label: string): void {
+  if (!enabled) return;
+  try {
+    writeSync(
+      STDERR_FD,
+      `gno-phase ${Math.round(performance.now())} ${process.pid} ${label}\n`
+    );
+  } catch {
+    // A closed stderr must never fail the traced command.
+  }
+}

package/src/core/write-lease.ts

@@ -11,6 +11,7 @@ import { dirname, join } from "node:path";
 
 import { getIndexDbPath } from "../app/constants";
 import { acquireWriteLock } from "./file-lock";
+import { tracePhase } from "./phase-trace";
 
 export const DEFAULT_LOCK_WAIT_MS = 120_000;
 export const WRITE_LEASE_BUSY_MESSAGE =
@@ -149,6 +150,7 @@ export async function acquireCliWriteLease(
   options: AcquireCliWriteLeaseOptions
 ): Promise<WriteLeaseResult> {
   const lockPath = writeLeasePath(options.dbPath);
+  tracePhase("lease: acquiring");
   // A non-finite or out-of-range wait must never loop unbounded (fn-127 review).
   const requestedWaitMs = Number.isFinite(options.waitMs)
     ? Math.min(Math.max(0, options.waitMs), MAX_LOCK_WAIT_MS)
@@ -163,7 +165,9 @@ export async function acquireCliWriteLease(
     const sliceMs = options.noWait ? 0 : Math.min(LOCK_SLICE_MS, remaining);
     const handle = await acquireWriteLock(lockPath, sliceMs);
     if (handle) {
+      tracePhase("lease: acquired");
       await writeHolderSidecar(lockPath, options.command);
+      tracePhase("lease: holder recorded");
       return {
         ok: true,
         release: async () => {
@@ -213,6 +217,7 @@ export async function withCliWriteLease<T>(
   } finally {
     try {
       await result.release();
+      tracePhase("lease: released");
     } catch (cause) {
       const message = cause instanceof Error ? cause.message : String(cause);
       process.stderr.write(`gno: failed to release write lease: ${message}\n`);

package/src/index.ts

@@ -7,6 +7,7 @@
  */
 
 import { runCli } from "./cli/run";
+import { tracePhase } from "./core/phase-trace";
 import { FILE_PROCESSOR_CHILD_ENV } from "./ingestion/file-child-env";
 import { resetModelManager } from "./llm/nodeLlamaCpp/lifecycle";
 import { IMPORT_CHILD_ENV } from "./sessions/import-child-env";
@@ -50,6 +51,7 @@ async function cleanupAndExit(code: number): Promise<never> {
   await resetModelManager().catch(() => {
     // Ignore cleanup errors on exit
   });
+  tracePhase("exit: models reset");
   await Promise.all([flushStream(process.stdout), flushStream(process.stderr)]);
   process.exit(code);
 }
@@ -89,8 +91,12 @@ if (process.env[FILE_PROCESSOR_CHILD_ENV] === "1") {
 }
 
 // Await module completion so pending piped stdin keeps Windows Bun alive.
+tracePhase("cli: start");
 await runCli(process.argv)
-  .then((code) => cleanupAndExit(interruptExitCode || code))
+  .then((code) => {
+    tracePhase(`cli: done (${code})`);
+    return cleanupAndExit(interruptExitCode || code);
+  })
   .catch((err) => {
     process.stderr.write(
       `Fatal error: ${err instanceof Error ? err.message : String(err)}\n`

package/src/ingestion/file-processor.ts

@@ -37,6 +37,7 @@ import type {
   PrepareOutcome,
 } from "./prepare-file";
 
+import { tracePhase } from "../core/phase-trace";
 import { isBunfsPath } from "../serve/spa-production-build";
 import { FILE_PROCESSOR_CHILD_ENV } from "./file-child-env";
 import { PREPARE_PHASES } from "./prepare-file";
@@ -452,7 +453,9 @@ const runOne = async (
   }
   // Loading the processor is not the file's time: its clock starts once the
   // processor can take it.
+  tracePhase(`processor: awaiting ${active.kind}`);
   const notReady = await awaitReady(active);
+  tracePhase(`processor: ${notReady ?? "ready"}`);
   if (notReady) {
     if (processor === active) stopProcessor();
     return { ok: false, error: unavailableFailure(notReady) };

package/src/ingestion/sync.ts

@@ -43,6 +43,7 @@ import {
   type DocumentStructureSnapshot,
 } from "../core/change-diff";
 import { enforceCollectionEgress } from "../core/egress-enforcement";
+import { tracePhase } from "../core/phase-trace";
 import { defaultChunker } from "./chunker";
 import { persistChunkLayout, prepareChunking } from "./chunking";
 import {
@@ -433,6 +434,7 @@ export class SyncService {
         "Compiled context is derived material; index original sources instead",
     };
     if (isCompiledContextPath(entry.relPath)) return generatedResult;
+    tracePhase(`sync: file ${entry.relPath}`);
     const limits = {
       maxBytes: options.limits?.maxBytes ?? DEFAULT_LIMITS.maxBytes,
       timeoutMs: options.limits?.timeoutMs ?? DEFAULT_LIMITS.timeoutMs,
@@ -499,6 +501,7 @@ export class SyncService {
         extensionMime.mime,
         extensionMime.ext
       );
+      tracePhase("sync: record adapter selected");
       const contentTypeRules = options.contentTypeRules ?? [];
       const contentTypeRulesFingerprint =
         options.contentTypeRulesFingerprint ??
@@ -673,6 +676,7 @@ export class SyncService {
       let previousStructure: DocumentStructureSnapshot | null | undefined =
         existing ? undefined : null;
       const previous = await this.readPreviousRevision(store, existing);
+      tracePhase("sync: preparing file");
       const prepared = await this.prepare(
         {
           input: {
@@ -1626,7 +1630,9 @@ export class SyncService {
       sourceAvailability: availabilityMode,
       directoryAvailability,
     };
+    tracePhase(`sync: walking ${collection.name}`);
     const { entries, skipped } = await this.walker.walk(walkConfig);
+    tracePhase(`sync: walked ${entries.length} entries`);
 
     // Track seen paths for marking inactive
     // Only include TOO_LARGE files (they exist but are unprocessable)
@@ -1945,7 +1951,9 @@ export class SyncService {
     options: SyncOptions = {}
   ): Promise<SyncResult> {
     const startTime = Date.now();
+    tracePhase("sync: preparing chunking");
     const prepared = await prepareChunking(store, this.chunker, options);
+    tracePhase("sync: chunking prepared");
     const results: CollectionSyncResult[] = [];
     const deferredProjectionOptions: SyncOptions = {
       ...prepared.options,
@@ -1961,6 +1969,7 @@ export class SyncService {
       results.push(result);
     }
 
+    tracePhase("sync: collections done");
     let graphRebuild: SyncResult["graphRebuild"];
     if (results.length > 0) {
       const projectionErrors = await this.projectTypedEdges(store, {
@@ -1973,6 +1982,7 @@ export class SyncService {
       results.at(-1)?.errors.push(...projectionErrors);
     }
 
+    tracePhase("sync: typed edges projected");
     // Aggregate totals
     const totals = results.reduce(
       (acc, r) => ({

package/src/serve/watch-reconciliation-shared.ts

@@ -42,9 +42,20 @@ export const WATCHER_MAX_DIRTY_HINTS = 4_096;
 /** Cap on application-write suppression history entries. */
 export const WATCHER_MAX_SUPPRESSION_ENTRIES = 4_096;
 
-/** Bounded retry delay after failed classification/sync. */
+/** Retry delay after the first failed classification/sync of a collection. */
 export const WATCHER_RETRY_BACKOFF_MS = 500;
 
+/** Ceiling for the retry delay while a collection keeps failing. */
+export const WATCHER_MAX_RETRY_BACKOFF_MS = 5 * 60_000;
+
+/** Delay before the retry that follows `failures` consecutive failed flushes. */
+export function watcherRetryDelayMs(failures: number): number {
+  return Math.min(
+    WATCHER_RETRY_BACKOFF_MS * 2 ** Math.max(0, failures - 1),
+    WATCHER_MAX_RETRY_BACKOFF_MS
+  );
+}
+
 /** Retry delay while another writer holds the shared writer lease. */
 export const WATCHER_LEASE_RETRY_MS = 5_000;
 

package/src/serve/watch-reconciliation.ts

@@ -28,6 +28,7 @@ export {
   WATCHER_MAX_DIRTY_HINTS,
   WATCHER_MAX_EXACT_PATHS,
   WATCHER_MAX_FLUSH_DELAY_MS,
+  WATCHER_MAX_RETRY_BACKOFF_MS,
   WATCHER_MAX_SUPPRESSION_ENTRIES,
   WATCHER_RETRY_BACKOFF_MS,
   addToCappedSet,
@@ -39,6 +40,7 @@ export {
   mergeSyncPathBatch,
   pruneSuppressionMap,
   successfulChangedPaths,
+  watcherRetryDelayMs,
   widenVanishedExactPaths,
   type ClassificationResult,
   type ExactPathKind,

package/src/serve/watch-service-events.ts

@@ -12,8 +12,8 @@ import type { Collection } from "../config/types";
 import {
   WATCHER_FLUSH_DEBOUNCE_MS,
   WATCHER_MAX_FLUSH_DELAY_MS,
-  WATCHER_RETRY_BACKOFF_MS,
   classifyWatcherFilename,
+  watcherRetryDelayMs,
 } from "./watch-reconciliation";
 import {
   applyPendingForceFlags,
@@ -25,6 +25,12 @@ import {
   type PendingForceFlags,
 } from "./watch-service-state";
 
+/**
+ * Why an explicit retry timer is armed: "backoff" after a failed flush, "fixed"
+ * for an explicit delay such as writer-lease contention (R3: stays at 5 s).
+ */
+export type WatcherRetryKind = "backoff" | "fixed";
+
 export interface WatchEventHost {
   disposed: () => boolean;
   findCollection: (collectionName: string) => Collection | undefined;
@@ -45,8 +51,12 @@ export interface WatchQueueHost {
   pendingByCollection: Map<string, CollectionPending>;
   flushDeadlineAt: Map<string, number>;
   timers: Map<string, ReturnType<typeof setTimeout>>;
-  /** Collections with an explicit retry timer; finally must not bypass. */
-  retryScheduled: Set<string>;
+  /** Collections with an explicit retry timer, by kind; finally must not bypass. */
+  retryScheduled: Map<string, WatcherRetryKind>;
+  /** Consecutive failed flushes per collection; cleared by a successful flush. */
+  retryFailures: Map<string, number>;
+  /** Collections with watcher events queued since their last flush took its work. */
+  freshEvents: Set<string>;
   snapshotReady: Map<string, boolean>;
   inFlightSyncs: Set<Promise<void>>;
   runFlush: (collectionName: string) => Promise<void>;
@@ -105,6 +115,7 @@ export function enqueueExactPath(
     collectionName,
     queueExactPath(pending, relPath, host.maxExactPaths)
   );
+  host.freshEvents.add(collectionName);
   scheduleFlush(host, collectionName);
 }
 
@@ -123,6 +134,7 @@ export function enqueueDirtyHint(
     collectionName,
     queueDirtyHint(pending, hint, host.maxDirtyHints)
   );
+  host.freshEvents.add(collectionName);
   scheduleFlush(host, collectionName);
 }
 
@@ -152,9 +164,17 @@ export function scheduleFlush(
   if (host.disposed()) {
     return;
   }
-  // Explicit retry owns the single timer; do not replace it with debounce.
-  if (host.retryScheduled.has(collectionName)) {
-    return;
+  const retryKind = host.retryScheduled.get(collectionName);
+  if (retryKind !== undefined) {
+    // Explicit retry owns the single timer; do not replace it with debounce.
+    if (retryKind === "fixed" || !host.freshEvents.has(collectionName)) {
+      return;
+    }
+    // A fresh event never waits out a failure backoff: drop the retry timer and
+    // flush on the normal debounce. The failure count stays until a flush succeeds.
+    // A fixed (lease) retry keeps its timer so a held lease is not probed per event.
+    host.retryScheduled.delete(collectionName);
+    host.flushDeadlineAt.delete(collectionName);
   }
   const schedule = computeFlushDelay({
     nowMs: host.clock(),
@@ -213,6 +233,8 @@ export function startFlush(host: WatchQueueHost, collectionName: string): void {
  * Re-arm pending work after a file-level failure with retry backoff.
  * At most one retry timer per collection; finally must not startFlush while set.
  * forceFallback/overflow survive until forced classification + sync succeed.
+ * Without an explicit delay, each consecutive failure doubles the wait (capped),
+ * so work that fails the same way every time cannot spin the resident.
  */
 export function requeueAfterFailure(
   host: WatchQueueHost,
@@ -220,7 +242,7 @@ export function requeueAfterFailure(
   exact: string[],
   dirty: string[],
   forceFlags?: PendingForceFlags,
-  delayMs = WATCHER_RETRY_BACKOFF_MS
+  delayMs?: number
 ): void {
   queueWithoutSchedule(host, collectionName, exact, dirty, forceFlags);
   if (host.disposed()) {
@@ -230,7 +252,19 @@ export function requeueAfterFailure(
     // Pending already merged; existing retry timer remains the sole attempt.
     return;
   }
-  host.retryScheduled.add(collectionName);
+  host.retryScheduled.set(
+    collectionName,
+    delayMs === undefined ? "backoff" : "fixed"
+  );
+  let retryDelayMs = delayMs;
+  if (retryDelayMs === undefined) {
+    const failures = (host.retryFailures.get(collectionName) ?? 0) + 1;
+    host.retryFailures.set(collectionName, failures);
+    // Events that arrived while the failed flush ran flush on the debounce.
+    retryDelayMs = host.freshEvents.has(collectionName)
+      ? host.flushDebounceMs
+      : watcherRetryDelayMs(failures);
+  }
   const existingTimer = host.timers.get(collectionName);
   if (existingTimer) {
     clearTimeout(existingTimer);
@@ -242,7 +276,7 @@ export function requeueAfterFailure(
       host.timers.delete(collectionName);
       host.retryScheduled.delete(collectionName);
       startFlush(host, collectionName);
-    }, delayMs)
+    }, retryDelayMs)
   );
 }
 

package/src/serve/watch-service-hosts.ts

@@ -8,7 +8,11 @@ import type { FSWatcher } from "node:fs";
 
 import type { Collection } from "../config/types";
 import type { SyncOptions } from "../ingestion";
-import type { WatchEventHost, WatchQueueHost } from "./watch-service-events";
+import type {
+  WatchEventHost,
+  WatchQueueHost,
+  WatcherRetryKind,
+} from "./watch-service-events";
 import type { WatchLifecycleHost } from "./watch-service-lifecycle";
 import type { CollectionPending } from "./watch-service-state";
 import type { WatcherSnapshot } from "./watch-snapshot";
@@ -46,7 +50,9 @@ export interface WatchServiceHostState {
   maxDirtyHints: number;
   flushDeadlineAt: Map<string, number>;
   timers: Map<string, ReturnType<typeof setTimeout>>;
-  retryScheduled: Set<string>;
+  retryScheduled: Map<string, WatcherRetryKind>;
+  retryFailures: Map<string, number>;
+  freshEvents: Set<string>;
   inFlightSyncs: Set<Promise<void>>;
   runFlush: (collectionName: string) => Promise<void>;
 }
@@ -71,6 +77,8 @@ export function buildLifecycleHost(
     snapshotInit: state.snapshotInit,
     syncing: state.syncing,
     pendingByCollection: state.pendingByCollection,
+    retryFailures: state.retryFailures,
+    freshEvents: state.freshEvents,
     clearCollectionRuntimeState: state.clearCollectionRuntimeState,
     beginSnapshotInit: state.beginSnapshotInit,
     watchFactory: state.watchFactory,
@@ -102,6 +110,8 @@ export function buildQueueHost(state: WatchServiceHostState): WatchQueueHost {
     flushDeadlineAt: state.flushDeadlineAt,
     timers: state.timers,
     retryScheduled: state.retryScheduled,
+    retryFailures: state.retryFailures,
+    freshEvents: state.freshEvents,
     snapshotReady: state.snapshotReady,
     inFlightSyncs: state.inFlightSyncs,
     runFlush: state.runFlush,

package/src/serve/watch-service-lifecycle.ts

@@ -38,6 +38,10 @@ export interface WatchLifecycleHost {
    * forceFallback + durable generation reconcile so a new baseline cannot absorb it.
    */
   pendingByCollection: Map<string, CollectionPending>;
+  /** Consecutive failed flushes per collection (failure backoff input). */
+  retryFailures: Map<string, number>;
+  /** Collections whose queued work is new user action, not a failure retry. */
+  freshEvents: Set<string>;
   clearCollectionRuntimeState: (collectionName: string) => void;
   beginSnapshotInit: (collection: Collection) => void;
   watchFactory: (
@@ -186,6 +190,10 @@ export function applyCollectionUpdate(
         pending.forceFallback = true;
       }
       host.pendingByCollection.set(collection.name, pending);
+      // A config edit is user action that may fix the failure cause: it must
+      // not wait out an armed failure backoff, and the count starts over.
+      host.freshEvents.add(collection.name);
+      host.retryFailures.delete(collection.name);
     }
     if (host.watchers.has(collection.name)) {
       host.beginSnapshotInit(collection);

package/src/serve/watch-service-run-flush.ts

@@ -10,7 +10,7 @@ import { normalize } from "node:path";
 import type { Collection } from "../config/types";
 import type { CollectionSyncResult, SyncOptions } from "../ingestion";
 import type { SqliteAdapter } from "../store/sqlite/adapter";
-import type { WatchQueueHost } from "./watch-service-events";
+import type { WatchQueueHost, WatcherRetryKind } from "./watch-service-events";
 import type { CollectionPending } from "./watch-service-state";
 import type { WatcherSnapshot, WatcherSnapshotFs } from "./watch-snapshot";
 
@@ -36,7 +36,7 @@ export interface RunFlushContext {
   pendingByCollection: Map<string, CollectionPending>;
   flushDeadlineAt: Map<string, number>;
   syncing: Set<string>;
-  retryScheduled: Set<string>;
+  retryScheduled: Map<string, WatcherRetryKind>;
   collectionGenerations: Map<string, number>;
   snapshots: Map<string, WatcherSnapshot>;
   snapshotReady: Map<string, boolean>;
@@ -125,6 +125,7 @@ export async function runOwnedCollectionFlush(
   }
 
   // Events that arrived while the lease was being taken join this flush.
+  ctx.queueHost.freshEvents.delete(collectionName);
   const taken = takePending(
     ctx.pendingByCollection.get(collectionName) ?? pending
   );
@@ -148,6 +149,9 @@ export async function runOwnedCollectionFlush(
     );
   };
 
+  // A flush can requeue failed work (e.g. a dirty classification error) and
+  // still settle as synced/idle; that must not reset the failure backoff.
+  let requeuedFailure = false;
   try {
     const outcome = await flushCollectionOnce({
       collection,
@@ -218,6 +222,7 @@ export async function runOwnedCollectionFlush(
         if (!stillOwner()) {
           return;
         }
+        requeuedFailure = true;
         requeueAfterFailure(
           ctx.queueHost,
           collectionName,
@@ -236,6 +241,12 @@ export async function runOwnedCollectionFlush(
         requeueGenerationReconcile(ctx.queueHost, collectionName);
       },
     });
+    if (
+      (outcome.status === "synced" || outcome.status === "idle") &&
+      !requeuedFailure
+    ) {
+      ctx.queueHost.retryFailures.delete(collectionName);
+    }
     if (
       outcome.status === "failed" &&
       outcome.error &&

package/src/serve/watch-service.ts

@@ -15,6 +15,7 @@ import type { CollectionSyncResult, SyncOptions } from "../ingestion";
 import type { SqliteAdapter } from "../store/sqlite/adapter";
 import type { DocumentEvent, DocumentEventBus } from "./doc-events";
 import type { EmbedScheduler } from "./embed-scheduler";
+import type { WatcherRetryKind } from "./watch-service-events";
 import type {
   WatcherSnapshot,
   WatcherSnapshotBuildResult,
@@ -126,7 +127,9 @@ export class CollectionWatchService {
   readonly #pendingByCollection = new Map<string, CollectionPending>();
   readonly #timers = new Map<string, ReturnType<typeof setTimeout>>();
   readonly #flushDeadlineAt = new Map<string, number>();
-  readonly #retryScheduled = new Set<string>();
+  readonly #retryScheduled = new Map<string, WatcherRetryKind>();
+  readonly #retryFailures = new Map<string, number>();
+  readonly #freshEvents = new Set<string>();
   readonly #syncing = new Set<string>();
   readonly #inFlightSyncs = new Set<Promise<void>>();
   readonly #suppressedPaths = new Map<string, number>();
@@ -216,6 +219,8 @@ export class CollectionWatchService {
     this.#timers.clear();
     this.#flushDeadlineAt.clear();
     this.#retryScheduled.clear();
+    this.#retryFailures.clear();
+    this.#freshEvents.clear();
     this.#watchers.clear();
     this.#watchRoots.clear();
     this.#collectionGenerations.clear();
@@ -303,6 +308,8 @@ export class CollectionWatchService {
       flushDeadlineAt: this.#flushDeadlineAt,
       timers: this.#timers,
       retryScheduled: this.#retryScheduled,
+      retryFailures: this.#retryFailures,
+      freshEvents: this.#freshEvents,
       inFlightSyncs: this.#inFlightSyncs,
       runFlush: (name) => this.#flushCollection(name),
     };
@@ -316,6 +323,8 @@ export class CollectionWatchService {
     this.#snapshotInit.delete(collectionName);
     this.#flushDeadlineAt.delete(collectionName);
     this.#retryScheduled.delete(collectionName);
+    this.#retryFailures.delete(collectionName);
+    this.#freshEvents.delete(collectionName);
     const timer = this.#timers.get(collectionName);
     if (timer) {
       clearTimeout(timer);

package/src/store/sqlite/adapter.ts

@@ -145,6 +145,7 @@ import {
   type LinkWorkspaceSource,
 } from "../../core/link-workspace";
 import { normalizeWikiName, stripWikiMdExt } from "../../core/links";
+import { tracePhase } from "../../core/phase-trace";
 import {
   TYPED_METADATA_INGEST_VERSION,
   typedMetadataSchema,
@@ -615,6 +616,7 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
   ): Promise<StoreResult<MigrationResult>> {
     try {
       this.db = new Database(dbPath, { create: true });
+      tracePhase("db: connection open");
       this.shutdownFenced = false;
       this.shutdownDeadline = undefined;
       this.dbPath = dbPath;
@@ -633,8 +635,10 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
         const journalMode = this.db
           .query<{ journal_mode: string }, []>("PRAGMA journal_mode")
           .get()?.journal_mode;
+        tracePhase(`db: journal_mode ${journalMode}`);
         if (journalMode?.toLowerCase() !== "wal") {
           this.db.exec("PRAGMA journal_mode = WAL");
+          tracePhase("db: journal_mode set to wal");
         }
       } catch (cause) {
         if (!isDatabaseLockedError(cause)) {
@@ -664,7 +668,9 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
       }
 
       // Run migrations
+      tracePhase("db: migrations");
       const result = runMigrations(this.db, migrations, ftsTokenizer);
+      tracePhase("db: migrations done");
       if (!result.ok) {
         this.db.close();
         this.db = null;

package/browser-extension/artifacts/gno-browser-clipper-v2.8.5.zip.sha256

@@ -1 +0,0 @@
-347695588c724660218a91ae70cd7bd8420445d2f78dd293cf661626380db7f2  gno-browser-clipper-v2.8.5.zip