@gmickel/gno 2.8.3 → 2.8.5

package/README.md

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

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

@@ -0,0 +1 @@
+347695588c724660218a91ae70cd7bd8420445d2f78dd293cf661626380db7f2  gno-browser-clipper-v2.8.5.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.3"
+  "version": "2.8.5"
 }

package/package.json

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

package/spec/cli.md

@@ -351,7 +351,12 @@ gno status [--json|--md]
 ```
 
 `activation.usable` means at least one configured collection passed its local
-lexical proof. `activation.healthy` means every configured collection passed.
+lexical proof. `activation.healthy` means at least one collection is configured
+and none failed its proof. A collection with no documents yet (index stage
+`no_documents`, remediation `gno update`) is informational, not a failure: it
+leaves `healthy` true, projects no connector proofs, and terminal output
+lists it as `no documents yet` (`Lexical activation: NO DOCUMENTS YET` when no
+collection has documents).
 Semantic and connector stages remain independent; passive status never starts a
 model runtime or connector process. `gno status` still exits 0 when activation
 is unhealthy so scripts can inspect the structured state.
@@ -401,11 +406,19 @@ Passive callers report `semantic_not_checked` when vector runtime availability
 is unknown. `vector_unavailable` is reserved for a resident runtime that has
 positively reported vector search unavailable.
 
-`connectorProjection.total` counts every configured collection and connector
-target pair before projection bounds. `projected` equals `connectors.length`,
-and `truncated` is true exactly when `total > projected`. No result is claimed
-for omitted pairs, and human-readable health output must not report connector
-proof as healthy while the projection is truncated.
+`connectorProjection.total` counts every non-empty collection and connector
+target pair. Every pair is evaluated from cached receipts; the 64-pair cap
+bounds only the listed `connectors`. `projected` equals `connectors.length`,
+and `truncated` is true exactly when `total > projected`. When truncated,
+`omitted` counts the unlisted pairs by outcome (`passed`, `failed`,
+`incomplete`, `notApplicable`; the counts sum to `total - projected`). Connector
+completeness, and so overall health, is decided from the listed pairs plus
+these counts: a truncated projection whose pairs all passed or are not
+applicable is healthy, and a failed or pending pair beyond the list keeps it
+degraded. Human-readable output keeps the `N/M ... shown; K omitted` line and
+summarizes the omitted outcomes, for example `(108 passed, 1 failed)`. A
+truncated projection without `omitted` claims no result for the unlisted pairs
+and is never reported healthy.
 
 **Exit Codes:**
 
@@ -3022,7 +3035,11 @@ The additive `activation` object uses the same contract as `gno status` and
 `GET /api/status`. Doctor performs only the local lexical proof. It never starts
 connector children or initializes/downloads models. A failed lexical proof adds
 the `retrieval-activation` error check and exits 2 after writing the complete
-result; no duplicate error is written to stderr. Connector failure or projection
+result; no duplicate error is written to stderr. A collection with no
+documents yet is not a failed proof: when it is the only activation problem,
+`retrieval-activation` has status `info` (terminal icon `i`) and lists the
+collection with its remediation (add files, then `gno update`). Check status
+is one of `ok`, `info`, `warn` or `error`; only `error` fails doctor. Connector failure or projection
 truncation adds a warning and makes the structured doctor result non-healthy,
 but preserves exit 0 when lexical proof and all other required checks pass. An
 omitted target/collection pair has no inferred result.

package/spec/output-schemas/doctor.schema.json

@@ -24,8 +24,14 @@
       ],
       "properties": {
         "schemaVersion": { "const": "1.0" },
-        "usable": { "type": "boolean" },
-        "healthy": { "type": "boolean" },
+        "usable": {
+          "type": "boolean",
+          "description": "At least one collection passed the lexical retrieval proof"
+        },
+        "healthy": {
+          "type": "boolean",
+          "description": "At least one collection is configured and none failed its lexical retrieval proof. A collection with no documents yet (remediation code no_documents, command gno update) is informational, not a failure."
+        },
         "collections": {
           "type": "array",
           "items": {
@@ -158,7 +164,7 @@
             "total": {
               "type": "integer",
               "minimum": 0,
-              "description": "All configured collection and connector target pairs before projection bounds."
+              "description": "All non-empty collection and connector target pairs; every pair is evaluated from cached receipts."
             },
             "projected": {
               "type": "integer",
@@ -168,7 +174,27 @@
             },
             "truncated": {
               "type": "boolean",
-              "description": "True exactly when total is greater than projected; omitted pairs have no claimed result."
+              "description": "True exactly when total is greater than projected. Omitted pairs are still evaluated; their outcomes are counted in omitted."
+            },
+            "omitted": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["passed", "failed", "incomplete", "notApplicable"],
+              "description": "Present when truncated: outcome counts for the evaluated pairs not listed in connectors. The counts sum to total - projected. Connector completeness is decided from connectors plus these counts.",
+              "properties": {
+                "passed": { "type": "integer", "minimum": 0 },
+                "failed": { "type": "integer", "minimum": 0 },
+                "incomplete": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "description": "Pending, or skipped for a runtime reason such as lexical retrieval not ready."
+                },
+                "notApplicable": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "description": "Connector not configured, or a skill runtime that cannot be verified."
+                }
+              }
             }
           }
         }
@@ -229,8 +255,8 @@
           },
           "status": {
             "type": "string",
-            "enum": ["ok", "warn", "error"],
-            "description": "Check result status"
+            "enum": ["ok", "info", "warn", "error"],
+            "description": "Check result status. info reports a state that needs no repair, such as a collection with no documents yet"
           },
           "message": {
             "type": "string",

package/spec/output-schemas/status.schema.json

@@ -347,10 +347,12 @@
           "const": "1.0"
         },
         "usable": {
-          "type": "boolean"
+          "type": "boolean",
+          "description": "At least one collection passed the lexical retrieval proof"
         },
         "healthy": {
-          "type": "boolean"
+          "type": "boolean",
+          "description": "At least one collection is configured and none failed its lexical retrieval proof. A collection with no documents yet (remediation code no_documents, command gno update) is informational, not a failure."
         },
         "collections": {
           "type": "array",
@@ -512,7 +514,7 @@
             "total": {
               "type": "integer",
               "minimum": 0,
-              "description": "All configured collection and connector target pairs before projection bounds."
+              "description": "All non-empty collection and connector target pairs; every pair is evaluated from cached receipts."
             },
             "projected": {
               "type": "integer",
@@ -522,7 +524,27 @@
             },
             "truncated": {
               "type": "boolean",
-              "description": "True exactly when total is greater than projected; omitted pairs have no claimed result."
+              "description": "True exactly when total is greater than projected. Omitted pairs are still evaluated; their outcomes are counted in omitted."
+            },
+            "omitted": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["passed", "failed", "incomplete", "notApplicable"],
+              "description": "Present when truncated: outcome counts for the evaluated pairs not listed in connectors. The counts sum to total - projected. Connector completeness is decided from connectors plus these counts.",
+              "properties": {
+                "passed": { "type": "integer", "minimum": 0 },
+                "failed": { "type": "integer", "minimum": 0 },
+                "incomplete": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "description": "Pending, or skipped for a runtime reason such as lexical retrieval not ready."
+                },
+                "notApplicable": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "description": "Connector not configured, or a skill runtime that cannot be verified."
+                }
+              }
             }
           }
         }

package/src/cli/commands/doctor-activation.ts

@@ -6,6 +6,12 @@ import type { StorePort } from "../../store/types";
 import type { DoctorCheck } from "./doctor";
 
 import { getIndexDbPath, getModelsCachePath } from "../../app/constants";
+import {
+  classifyConnectorProof,
+  describeOmittedConnectorPairs,
+  omittedConnectorSummary,
+} from "../../core/activation-connector-health";
+import { isEmptyActivationCollection } from "../../core/activation-empty";
 import { buildActivationStatus } from "../../core/activation-status";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset } from "../../llm/registry";
@@ -75,28 +81,54 @@ export async function buildDoctorActivation(
   }
 }
 
+const plural = (count: number, noun: string): string =>
+  `${count} ${noun}${count === 1 ? "" : "s"}`;
+
 export function checkRetrievalActivation(
   activation: ActivationStatus
 ): DoctorCheck {
+  const ready = activation.collections.filter((collection) => collection.ready);
+  const empty = activation.collections.filter(isEmptyActivationCollection);
+  const emptyDetails = empty.flatMap(({ collection, remediation }) => [
+    `${collection}: no documents indexed yet (informational)`,
+    `Add files, then run: ${remediation?.command ?? "gno update"}`,
+  ]);
+
   if (activation.healthy) {
     const semanticStates = [
       ...new Set(
-        activation.collections.map(
-          ({ semanticAvailability }) => semanticAvailability.code
-        )
+        ready.map(({ semanticAvailability }) => semanticAvailability.code)
       ),
     ];
+    const semanticDetail =
+      ready.length > 0
+        ? [
+            `Semantic retrieval remains separate (${semanticStates.join(", ")}).`,
+          ]
+        : [];
+    if (empty.length === 0) {
+      return {
+        name: "retrieval-activation",
+        status: "ok",
+        message: `${plural(ready.length, "collection")} passed lexical retrieval proof`,
+        details: semanticDetail,
+      };
+    }
     return {
       name: "retrieval-activation",
-      status: "ok",
-      message: `${activation.collections.length} collection${activation.collections.length === 1 ? "" : "s"} passed lexical retrieval proof`,
-      details: [
-        `Semantic retrieval remains separate (${semanticStates.join(", ")}).`,
-      ],
+      status: "info",
+      message:
+        ready.length > 0
+          ? `${plural(ready.length, "collection")} passed lexical retrieval proof; ${plural(empty.length, "collection")} with no documents yet`
+          : `No documents indexed yet in ${plural(empty.length, "collection")}`,
+      details: [...emptyDetails, ...semanticDetail],
     };
   }
 
-  const failed = activation.collections.filter(({ ready }) => !ready);
+  const failed = activation.collections.filter(
+    (collection) =>
+      !collection.ready && !isEmptyActivationCollection(collection)
+  );
   const details = failed.flatMap(({ collection, remediation }) =>
     remediation
       ? [
@@ -112,9 +144,9 @@ export function checkRetrievalActivation(
       activation.collections.length === 0
         ? "No collections configured. Run: gno collection add"
         : activation.usable
-          ? `${failed.length} collection${failed.length === 1 ? "" : "s"} failed lexical retrieval proof`
+          ? `${plural(failed.length, "collection")} failed lexical retrieval proof`
           : "No configured collection passed lexical retrieval proof",
-    details,
+    details: [...details, ...emptyDetails],
   };
 }
 
@@ -122,13 +154,14 @@ export function checkConnectorActivation(
   activation: ActivationStatus
 ): DoctorCheck | null {
   const { projected, total, truncated } = activation.connectorProjection;
-  const omitted = total - projected;
+  const omitted = omittedConnectorSummary(activation);
   const observed = activation.connectors.filter(
-    ({ code }) =>
-      code !== "connector_not_configured" &&
-      code !== "target_runtime_unverifiable"
+    (connector) => classifyConnectorProof(connector) !== "notApplicable"
   );
-  if (observed.length === 0 && !truncated) {
+  const omittedObserved = omitted
+    ? omitted.passed + omitted.failed + omitted.incomplete
+    : 0;
+  if (observed.length === 0 && omittedObserved === 0 && omitted) {
     return null;
   }
   const incomplete = observed.filter(({ status }) => status !== "passed");
@@ -136,20 +169,23 @@ export function checkConnectorActivation(
     ({ collection, target, status, code, remediation }) =>
       `${target}/${collection}: ${status}${code ? `/${code}` : ""}${remediation ? `. ${remediation}` : ""}`
   );
-  if (truncated) {
-    details.unshift(
-      `${omitted} target/collection checks were omitted by the bounded status projection; no result is claimed for them.`
-    );
+  const omittedDetail = describeOmittedConnectorPairs(activation);
+  if (omittedDetail) {
+    details.unshift(omittedDetail);
   }
+  const unresolved =
+    incomplete.length + (omitted ? omitted.failed + omitted.incomplete : 0);
+  const passed = observed.length - incomplete.length + (omitted?.passed ?? 0);
+  const listing = truncated ? ` (${projected} of ${total} checks listed)` : "";
   return {
     name: "connector-activation",
-    status: incomplete.length > 0 || truncated ? "warn" : "ok",
+    status: unresolved > 0 || !omitted ? "warn" : "ok",
     message:
-      incomplete.length > 0
-        ? `${incomplete.length} connector proof${incomplete.length === 1 ? "" : "s"} pending or failed`
-        : truncated
-          ? `${projected} of ${total} connector target/collection checks projected`
-          : `${observed.length} connector proof${observed.length === 1 ? "" : "s"} passed`,
+      unresolved > 0
+        ? `${unresolved} connector proof${unresolved === 1 ? "" : "s"} pending or failed${listing}`
+        : omitted
+          ? `${passed} connector proof${passed === 1 ? "" : "s"} passed${listing}`
+          : `${projected} of ${total} connector target/collection checks projected`,
     details,
   };
 }

package/src/cli/commands/doctor.ts

@@ -55,7 +55,8 @@ import {
 // Types
 // ─────────────────────────────────────────────────────────────────────────────
 
-export type DoctorCheckStatus = "ok" | "warn" | "error";
+/** `info` reports a state that needs no repair, such as an empty collection. */
+export type DoctorCheckStatus = "ok" | "info" | "warn" | "error";
 
 export interface DoctorCheck {
   name: string;
@@ -754,6 +755,8 @@ function statusIcon(status: DoctorCheckStatus): string {
   switch (status) {
     case "ok":
       return "✓";
+    case "info":
+      return "i";
     case "warn":
       return "!";
     case "error":

package/src/cli/commands/status.ts

@@ -18,7 +18,12 @@ import {
   isInitialized,
   loadConfig,
 } from "../../config";
-import { isConnectorActivationComplete } from "../../core/activation-connector-health";
+import {
+  describeConnectorSummary,
+  isConnectorActivationComplete,
+  omittedConnectorSummary,
+} from "../../core/activation-connector-health";
+import { isEmptyActivationCollection } from "../../core/activation-empty";
 import { buildActivationStatus } from "../../core/activation-status";
 import { formatChunkingStatus } from "../../core/chunking-status";
 import { formatLinkWorkspace } from "../../core/link-workspace";
@@ -145,7 +150,8 @@ function connectorProjectionLine(activation: ActivationStatus): string | null {
   if (!truncated) {
     return null;
   }
-  return `Connector projection: ${projected}/${total} target/collection checks shown; ${total - projected} omitted`;
+  const omitted = omittedConnectorSummary(activation);
+  return `Connector projection: ${projected}/${total} target/collection checks shown; ${total - projected} omitted${omitted ? ` (${describeConnectorSummary(omitted)})` : ", no result claimed"}`;
 }
 
 function isStatusHealthy(
@@ -229,10 +235,21 @@ function formatTerminal(
     `Health: ${isStatusHealthy(indexStatus, activation) ? "OK" : "DEGRADED"}`
   );
   lines.push("");
-  lines.push(
-    `Lexical activation: ${activation.healthy ? "READY" : activation.usable ? "DEGRADED" : "BLOCKED"}`
-  );
+  const activationState = activation.healthy
+    ? activation.usable
+      ? "READY"
+      : "NO DOCUMENTS YET"
+    : activation.usable
+      ? "DEGRADED"
+      : "BLOCKED";
+  lines.push(`Lexical activation: ${activationState}`);
   for (const collection of activation.collections) {
+    if (isEmptyActivationCollection(collection)) {
+      lines.push(
+        `  ${collection.collection}: no documents yet (add files, then run ${collection.remediation?.command})`
+      );
+      continue;
+    }
     const failedStage = collection.remediation?.stage;
     const suffix = failedStage
       ? ` (${failedStage}: ${collection.remediation?.code}; ${collection.remediation?.command})`
@@ -325,7 +342,7 @@ function formatMarkdown(
   lines.push(`- **Lexically healthy**: ${activation.healthy}`);
   for (const collection of activation.collections) {
     lines.push(
-      `- **${collection.collection}**: ${collection.ready ? "lexical ready" : `${collection.remediation?.stage ?? "index"} ${collection.remediation?.code ?? "index_query_failed"}`}`
+      `- **${collection.collection}**: ${collection.ready ? "lexical ready" : isEmptyActivationCollection(collection) ? `no documents yet (${collection.remediation?.command})` : `${collection.remediation?.stage ?? "index"} ${collection.remediation?.code ?? "index_query_failed"}`}`
     );
   }
   for (const connector of activation.connectors) {

package/src/core/activation-connector-health.ts

@@ -1,19 +1,111 @@
-import type { ActivationStatus } from "./activation-status";
+import type {
+  ActivationConnectorStatus,
+  ActivationStatus,
+  ConnectorOmittedSummary,
+} from "./activation-status";
 
 const NON_RUNTIME_CODES = new Set([
   "connector_not_configured",
   "target_runtime_unverifiable",
 ]);
 
-/** True when every observable proof passed and no target/collection pair was omitted. */
+export type ConnectorProofOutcome = keyof ConnectorOmittedSummary;
+
+/** One shared reading of a connector pair, used for listed and unlisted pairs alike. */
+export function classifyConnectorProof({
+  code,
+  status,
+}: Pick<ActivationConnectorStatus, "code" | "status">): ConnectorProofOutcome {
+  if (code !== undefined && NON_RUNTIME_CODES.has(code)) {
+    return "notApplicable";
+  }
+  if (status === "passed" || status === "failed") {
+    return status;
+  }
+  return "incomplete";
+}
+
+export function summarizeConnectorProofs(
+  connectors: readonly Pick<ActivationConnectorStatus, "code" | "status">[]
+): ConnectorOmittedSummary {
+  const summary: ConnectorOmittedSummary = {
+    passed: 0,
+    failed: 0,
+    incomplete: 0,
+    notApplicable: 0,
+  };
+  for (const connector of connectors) {
+    summary[classifyConnectorProof(connector)] += 1;
+  }
+  return summary;
+}
+
+/**
+ * Summary of the pairs past the display cap, or null when some were omitted
+ * without an evaluated result (fail closed).
+ */
+export function omittedConnectorSummary(
+  activation: ActivationStatus
+): ConnectorOmittedSummary | null {
+  const { omitted, projected, total, truncated } =
+    activation.connectorProjection;
+  if (!truncated) {
+    return { passed: 0, failed: 0, incomplete: 0, notApplicable: 0 };
+  }
+  if (!omitted) {
+    return null;
+  }
+  const counted =
+    omitted.passed +
+    omitted.failed +
+    omitted.incomplete +
+    omitted.notApplicable;
+  return counted === total - projected ? omitted : null;
+}
+
+/** Human summary of unlisted pairs, e.g. "108 passed, 1 failed". */
+export function describeConnectorSummary(
+  summary: ConnectorOmittedSummary
+): string {
+  const parts = [
+    summary.passed > 0 ? `${summary.passed} passed` : null,
+    summary.failed > 0 ? `${summary.failed} failed` : null,
+    summary.incomplete > 0 ? `${summary.incomplete} pending` : null,
+    summary.notApplicable > 0
+      ? `${summary.notApplicable} not configured or not verifiable`
+      : null,
+  ].filter(Boolean);
+  return parts.length > 0 ? parts.join(", ") : "none";
+}
+
+/** Sentence describing the pairs past the display cap, or null when none were omitted. */
+export function describeOmittedConnectorPairs(
+  activation: ActivationStatus
+): string | null {
+  const { projected, total, truncated } = activation.connectorProjection;
+  if (!truncated) {
+    return null;
+  }
+  const omitted = total - projected;
+  const summary = omittedConnectorSummary(activation);
+  return summary
+    ? `${omitted} more target/collection checks are not listed: ${describeConnectorSummary(summary)}.`
+    : `${omitted} target/collection checks were omitted by the bounded status projection; no result is claimed for them.`;
+}
+
+/**
+ * True when every collection/target pair, listed or not, passed or has a
+ * non-runtime code. Pairs omitted without an evaluated result fail closed.
+ */
 export function isConnectorActivationComplete(
   activation: ActivationStatus
 ): boolean {
-  if (activation.connectorProjection.truncated) {
+  const omitted = omittedConnectorSummary(activation);
+  if (!omitted || omitted.failed > 0 || omitted.incomplete > 0) {
     return false;
   }
-  return activation.connectors.every(
-    ({ code, status }) =>
-      (code !== undefined && NON_RUNTIME_CODES.has(code)) || status === "passed"
-  );
+  return activation.connectors.every((connector) => {
+    const outcome = classifyConnectorProof(connector);
+    return outcome === "passed" || outcome === "notApplicable";
+  });
 }

package/src/core/activation-empty.ts

@@ -0,0 +1,16 @@
+/**
+ * Empty-collection rule shared by server surfaces and the Web UI bundle, so
+ * it carries type imports only.
+ */
+
+import type { ActivationCollectionStatus } from "./activation-status";
+
+/**
+ * A collection with nothing indexed yet: its only activation problem is
+ * `no_documents`. Surfaces show it as informational, never as a failure.
+ */
+export function isEmptyActivationCollection(
+  collection: Pick<ActivationCollectionStatus, "ready" | "remediation">
+): boolean {
+  return !collection.ready && collection.remediation?.code === "no_documents";
+}

package/src/core/activation-status.ts

@@ -14,6 +14,8 @@ import type {
   ConnectorVerificationTarget,
 } from "./connector-verifier";
 
+import { summarizeConnectorProofs } from "./activation-connector-health";
+import { isEmptyActivationCollection } from "./activation-empty";
 import { createEphemeralActivationProbePlan } from "./activation-probe-plan";
 import { verifyLexicalActivation } from "./activation-verifier";
 import {
@@ -22,7 +24,7 @@ import {
 } from "./connector-verifier";
 
 const DEFAULT_CONCURRENCY = 4;
-const MAX_CONNECTOR_TARGETS = 16;
+/** Bounds the listed pairs only; completeness is decided from every pair. */
 const MAX_CONNECTOR_PROJECTIONS = 64;
 const CONNECTOR_CODES = new Set<ActivationVerificationCode>([
   "connector_not_configured",
@@ -73,7 +75,13 @@ export interface ActivationConnectorStatus {
 
 export interface ActivationStatus {
   schemaVersion: "1.0";
+  /** At least one collection passed the lexical proof. */
   usable: boolean;
+  /**
+   * At least one collection is configured and none failed its proof. A
+   * collection with no documents yet is not a failure (see
+   * `isEmptyActivationCollection`), so it does not clear this flag.
+   */
   healthy: boolean;
   collections: ActivationCollectionStatus[];
   /** Only fingerprint-current persisted connector receipts may appear here. */
@@ -82,9 +90,21 @@ export interface ActivationStatus {
     total: number;
     projected: number;
     truncated: boolean;
+    /** Outcome counts for the evaluated pairs past the display cap; present when truncated. */
+    omitted?: ConnectorOmittedSummary;
   };
 }
 
+/** Per-outcome counts of evaluated connector pairs that are not listed. */
+export interface ConnectorOmittedSummary {
+  passed: number;
+  failed: number;
+  /** Pending, or skipped for a runtime reason (for example lexical not ready). */
+  incomplete: number;
+  /** Not configured, or a skill runtime that cannot be verified. */
+  notApplicable: number;
+}
+
 export interface ActivationStatusOptions {
   concurrency?: number;
   semantic?: {
@@ -178,10 +198,13 @@ function remediationFor(
   stage: ActivationStageName,
   code: ActivationVerificationCode
 ): ActivationRemediation {
-  const command = `gno index ${collection} --no-embed`;
+  const command =
+    code === "no_documents"
+      ? "gno update"
+      : `gno index ${collection} --no-embed`;
   const messages: Partial<Record<ActivationVerificationCode, string>> = {
     no_documents:
-      "Index at least one supported text document in this collection.",
+      "No documents are indexed yet. Add supported files to this collection's folder, then run gno update.",
     no_probe_term:
       "Add searchable text or adjust the collection filters, then reindex.",
     index_query_failed:
@@ -319,14 +342,22 @@ async function buildConnectorStatuses(
   store: StorePort,
   collections: VerifiedCollection[],
   targets: readonly ConnectorVerificationTarget[]
-): Promise<{ items: ActivationConnectorStatus[]; total: number }> {
+): Promise<{
+  items: ActivationConnectorStatus[];
+  omitted: ConnectorOmittedSummary;
+  total: number;
+}> {
   const sortedTargets = [...targets].sort((a, b) => a.id.localeCompare(b.id));
-  const boundedTargets = sortedTargets.slice(0, MAX_CONNECTOR_TARGETS);
-  const allPairs = collections.flatMap((collection) =>
-    boundedTargets.map((target) => ({ collection, target }))
+  // A collection with no documents gives a connector nothing to prove.
+  const provable = collections.filter(
+    ({ projected }) => !isEmptyActivationCollection(projected)
+  );
+  const allPairs = provable.flatMap((collection) =>
+    sortedTargets.map((target) => ({ collection, target }))
   );
-  const items = await mapBounded(
-    allPairs.slice(0, MAX_CONNECTOR_PROJECTIONS),
+  // Every pair is read from cached receipts only; the cap bounds the listing.
+  const evaluated = await mapBounded(
+    allPairs,
     DEFAULT_CONCURRENCY,
     async ({ collection, target }) => {
       const fallback = connectorFallback(
@@ -363,7 +394,13 @@ async function buildConnectorStatuses(
       };
     }
   );
-  return { items, total: collections.length * sortedTargets.length };
+  return {
+    items: evaluated.slice(0, MAX_CONNECTOR_PROJECTIONS),
+    omitted: summarizeConnectorProofs(
+      evaluated.slice(MAX_CONNECTOR_PROJECTIONS)
+    ),
+    total: evaluated.length,
+  };
 }
 
 async function verifyCoalesced(
@@ -501,13 +538,20 @@ export async function buildActivationStatus(
     schemaVersion: "1.0",
     usable: projected.some((collection) => collection.ready),
     healthy:
-      projected.length > 0 && projected.every((collection) => collection.ready),
+      projected.length > 0 &&
+      projected.every(
+        (collection) =>
+          collection.ready || isEmptyActivationCollection(collection)
+      ),
     collections: projected,
     connectors: connectorStatuses.items,
     connectorProjection: {
       total: connectorStatuses.total,
       projected: connectorStatuses.items.length,
       truncated: connectorStatuses.total > connectorStatuses.items.length,
+      ...(connectorStatuses.total > connectorStatuses.items.length
+        ? { omitted: connectorStatuses.omitted }
+        : {}),
     },
   };
 }

package/src/core/links.ts

@@ -80,11 +80,53 @@ const UNSAFE_PERCENT_CODES = new Set(["%2F", "%5C", "%00", "%2f", "%5c"]);
 // Regex Patterns
 // ─────────────────────────────────────────────────────────────────────────────
 
+interface WikiLinkMatch {
+  index: number;
+  raw: string;
+  content: string;
+}
+
 /**
- * Wiki link: [[target]] or [[target|alias]] or [[target#anchor]] or [[collection:target]]
- * Captures: 1=content inside brackets
+ * Wiki links: [[target]], [[target|alias]], [[target#anchor]] or
+ * [[collection:target]]. Matches exactly what
+ * `/\[\[([^\]|]+(?:\|[^\]]+)?)\]\]/g` matches, in one pass: the content runs
+ * to the first `]`, which must be doubled; it must not start with `|`, and a
+ * `|` in it needs text after it. The regex rescanned to that `]` from every
+ * unclosed `[[`, so a note with thousands of them took minutes.
  */
-const WIKI_LINK_REGEX = /\[\[([^\]|]+(?:\|[^\]]+)?)\]\]/g;
+export function* findWikiLinks(
+  markdown: string
+): Generator<WikiLinkMatch, void, undefined> {
+  let nextClose = -2;
+  let nextPipe = -2;
+  let start = markdown.indexOf("[[");
+  while (start !== -1) {
+    const contentStart = start + 2;
+    if (nextClose < contentStart) {
+      nextClose = markdown.indexOf("]", contentStart);
+      if (nextClose === -1) return;
+    }
+    if (nextPipe !== -1 && nextPipe < contentStart) {
+      nextPipe = markdown.indexOf("|", contentStart);
+    }
+    const pipeInContent = nextPipe !== -1 && nextPipe < nextClose;
+    const matched =
+      markdown.charCodeAt(nextClose + 1) === 93 /* ] */ &&
+      nextClose > contentStart &&
+      nextPipe !== contentStart &&
+      (!pipeInContent || nextClose > nextPipe + 1);
+    if (matched) {
+      yield {
+        index: start,
+        raw: markdown.slice(start, nextClose + 2),
+        content: markdown.slice(contentStart, nextClose),
+      };
+      start = markdown.indexOf("[[", nextClose + 2);
+    } else {
+      start = markdown.indexOf("[[", start + 1);
+    }
+  }
+}
 
 /** Logseq embed: {{embed [[Page]]}} or {{embed ((block-id))}} */
 const LOGSEQ_EMBED_REGEX =
@@ -385,12 +427,9 @@ export function parseLinks(
   };
 
   // Parse wiki links
-  WIKI_LINK_REGEX.lastIndex = 0;
-  let match: RegExpExecArray | null;
-
-  while ((match = WIKI_LINK_REGEX.exec(markdown)) !== null) {
-    const startOffset = match.index;
-    const endOffset = startOffset + match[0].length;
+  for (const wiki of findWikiLinks(markdown)) {
+    const startOffset = wiki.index;
+    const endOffset = startOffset + wiki.raw.length;
 
     // Skip [[target]] nested in Logseq alias syntax: [Display]([[target]])
     if (
@@ -405,12 +444,10 @@ export function parseLinks(
       continue;
     }
 
-    const content = match[1];
-    if (!content) continue;
-
     // Parse [[target|alias]] (and table-escaped [[target\|alias]]) format
-    const { target: targetPart, alias: aliasText } =
-      splitWikiLinkContent(content);
+    const { target: targetPart, alias: aliasText } = splitWikiLinkContent(
+      wiki.content
+    );
     // Only set displayText if different from target
     const displayText =
       aliasText !== undefined && aliasText !== targetPart
@@ -421,11 +458,12 @@ export function parseLinks(
     if (!trimmedTarget) {
       continue;
     }
-    pushWikiLink(match[0], trimmedTarget, startOffset, endOffset, displayText);
+    pushWikiLink(wiki.raw, trimmedTarget, startOffset, endOffset, displayText);
   }
 
   // Parse Logseq embeds as links
   LOGSEQ_EMBED_REGEX.lastIndex = 0;
+  let match: RegExpExecArray | null;
 
   while ((match = LOGSEQ_EMBED_REGEX.exec(markdown)) !== null) {
     const startOffset = match.index;

package/src/ingestion/strip.ts

@@ -14,8 +14,10 @@
  * Code regions come from the CommonMark + GFM parser. GFM table parsing is
  * quadratic in the cells of one table (a 20,000-row table took minutes), so
  * text with a table over the cell budget is parsed without the table
- * extension: code spans, fences, indented code, blockquotes and lists keep
- * their CommonMark meaning, and only table-cell boundaries are lost.
+ * extension and without inline links and inline HTML, which rescan a
+ * table-sized paragraph once per row: code spans, fences, indented code,
+ * blockquotes and lists keep their CommonMark meaning; table-cell
+ * boundaries, link destinations and HTML tags no longer hide a backtick.
  *
  * @module src/ingestion/strip
  */
@@ -59,9 +61,6 @@ export interface ExcludedRange {
 /** Frontmatter at start of file (YAML between --- delimiters) */
 const FRONTMATTER_REGEX = /^---\r?\n[\s\S]*?(?:\r?\n)?---(?:\r?\n|$)/;
 
-/** HTML comments */
-const HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g;
-
 /**
  * Most `|` characters one blank-line-delimited block may hold before the
  * GFM table extension is left out of the parse. A GFM table only ends at a
@@ -132,13 +131,33 @@ const hasOversizedTable = (markdown: string): boolean => {
   return false;
 };
 
-/** GFM without tables: every GFM construct except table rows and cells. */
+/**
+ * Inline constructs left out with the table extension. Without table rules a
+ * large table is one paragraph, and these rescan it once per row: on every
+ * `]` link and image ends walk back through all the paragraph's earlier
+ * events looking for an opening `[` (an unmatched `]` per row made 8,000
+ * rows take 66 s), and inline HTML reads forward from every unclosed `<!--`
+ * to the paragraph's end. They only matter to code detection through a
+ * backtick inside a link destination or title or an inline HTML tag, which
+ * then reads as a code-span delimiter.
+ */
+const PARAGRAPH_RESCANNING_CONSTRUCTS = [
+  "labelEnd",
+  "gfmPotentialFootnoteCall",
+  "htmlText",
+];
+
+/**
+ * GFM without tables: every GFM construct except table rows and cells, and
+ * without the constructs in `PARAGRAPH_RESCANNING_CONSTRUCTS`.
+ */
 const GFM_WITHOUT_TABLES = {
   extensions: [
     gfmAutolinkLiteral(),
     gfmFootnote(),
     gfmStrikethrough(),
     gfmTaskListItem(),
+    { disable: { null: PARAGRAPH_RESCANNING_CONSTRUCTS } },
   ],
   mdastExtensions: [
     gfmAutolinkLiteralFromMarkdown(),
@@ -226,15 +245,15 @@ export function getExcludedRanges(markdown: string): ExcludedRange[] {
     });
   }
 
-  // 2. HTML comments
-  HTML_COMMENT_REGEX.lastIndex = 0;
-  let match: RegExpExecArray | null;
-  while ((match = HTML_COMMENT_REGEX.exec(markdown)) !== null) {
-    ranges.push({
-      start: match.index,
-      end: match.index + match[0].length,
-      kind: "html_comment",
-    });
+  // 2. HTML comments: each `<!--` to the first `-->` after it. Once no
+  // `-->` follows, no later comment can close either, so the scan stops;
+  // the regex /<!--[\s\S]*?-->/g rescanned to the end from every opener.
+  let open = markdown.indexOf("<!--");
+  while (open !== -1) {
+    const close = markdown.indexOf("-->", open + 4);
+    if (close === -1) break;
+    ranges.push({ start: open, end: close + 3, kind: "html_comment" });
+    open = markdown.indexOf("<!--", close + 3);
   }
 
   // 3. Code spans and fenced or indented code blocks, from the parser.
@@ -281,24 +300,47 @@ export function isExcluded(
   return false;
 }
 
+/**
+ * Largest `end` among each prefix of a start-sorted range list, built once
+ * per list. Ranges can overlap (a comment around a code span), so a range
+ * list's ends are not sorted and the prefix maximum stands in for them.
+ */
+const prefixMaxEnds = new WeakMap<readonly ExcludedRange[], Int32Array>();
+
+const getPrefixMaxEnds = (ranges: readonly ExcludedRange[]): Int32Array => {
+  let maxEnds = prefixMaxEnds.get(ranges);
+  if (maxEnds?.length !== ranges.length) {
+    maxEnds = new Int32Array(ranges.length);
+    let maxEnd = -1;
+    for (const [index, range] of ranges.entries()) {
+      maxEnd = Math.max(maxEnd, range.end);
+      maxEnds[index] = maxEnd;
+    }
+    prefixMaxEnds.set(ranges, maxEnds);
+  }
+  return maxEnds;
+};
+
 /**
  * Check if a range [start, end) intersects any excluded range.
- * More precise than isExcluded for multi-character matches.
+ * More precise than isExcluded for multi-character matches. Ranges must be
+ * sorted by start, as getExcludedRanges returns them; one lookup is a binary
+ * search, so checking every link of a large note stays linear.
  */
 export function rangeIntersectsExcluded(
   start: number,
   end: number,
-  excludedRanges: ExcludedRange[]
+  excludedRanges: readonly ExcludedRange[]
 ): boolean {
-  for (const range of excludedRanges) {
-    // Two ranges [a, b) and [c, d) intersect if a < d && c < b
-    if (start < range.end && range.start < end) {
-      return true;
-    }
-    // Early exit if we've passed the range (ranges are sorted)
-    if (range.start >= end) {
-      break;
-    }
+  // Ranges starting before `end` form a prefix; one of them intersects
+  // [start, end) exactly when the largest end among them passes `start`.
+  let low = 0;
+  let high = excludedRanges.length;
+  while (low < high) {
+    const mid = (low + high) >>> 1;
+    if ((excludedRanges[mid]?.start ?? end) < end) low = mid + 1;
+    else high = mid;
   }
-  return false;
+  if (low === 0) return false;
+  return (getPrefixMaxEnds(excludedRanges)[low - 1] ?? -1) > start;
 }

package/src/serve/activation-health.ts

@@ -3,6 +3,13 @@
 import type { ActivationStatus } from "../core/activation-status";
 import type { HealthCheck } from "./status-model";
 
+import {
+  classifyConnectorProof,
+  describeOmittedConnectorPairs,
+  omittedConnectorSummary,
+} from "../core/activation-connector-health";
+import { isEmptyActivationCollection } from "../core/activation-empty";
+
 function countLabel(count: number, singular: string): string {
   return `${count} ${count === 1 ? singular : `${singular}s`}`;
 }
@@ -10,26 +17,42 @@ function countLabel(count: number, singular: string): string {
 export function buildActivationCheck(
   activation: ActivationStatus
 ): HealthCheck {
+  const ready = activation.collections.filter((collection) => collection.ready);
+  const empty = activation.collections.filter(isEmptyActivationCollection);
+  const emptyDetail =
+    empty.length > 0
+      ? `${countLabel(empty.length, "folder")} ${empty.length === 1 ? "has" : "have"} no documents yet (${empty.map(({ collection }) => collection).join(", ")}): add files, then run update.`
+      : null;
   if (activation.healthy) {
     const semanticReasons = [
       ...new Set(
-        activation.collections.map(
-          ({ semanticAvailability }) => semanticAvailability.code
-        )
+        ready.map(({ semanticAvailability }) => semanticAvailability.code)
       ),
     ];
+    const semanticDetail =
+      ready.length > 0
+        ? `Lexical search is proven. Semantic availability is separate (${semanticReasons.join(", ")}).`
+        : null;
     return {
       id: "retrieval-activation",
       title: "Retrieval proof",
       status: "ok",
-      summary: `${countLabel(activation.collections.length, "folder")} passed lexical retrieval`,
-      detail: `Lexical search is proven. Semantic availability is separate (${semanticReasons.join(", ")}).`,
+      summary:
+        ready.length === 0
+          ? `No documents indexed yet in ${countLabel(empty.length, "folder")}`
+          : empty.length > 0
+            ? `${countLabel(ready.length, "folder")} passed lexical retrieval; ${countLabel(empty.length, "folder")} with no documents yet`
+            : `${countLabel(ready.length, "folder")} passed lexical retrieval`,
+      detail: [semanticDetail, emptyDetail].filter(Boolean).join(" "),
       actionLabel: "Run update",
       actionKind: "sync",
     };
   }
 
-  const failed = activation.collections.filter(({ ready }) => !ready);
+  const failed = activation.collections.filter(
+    (collection) =>
+      !collection.ready && !isEmptyActivationCollection(collection)
+  );
   const first = failed[0];
   const detail = first?.remediation
     ? `${first.collection}: ${first.remediation.stage}/${first.remediation.code}. Run: ${first.remediation.command}`
@@ -41,7 +64,7 @@ export function buildActivationCheck(
     summary: activation.usable
       ? `${countLabel(failed.length, "folder")} failed lexical retrieval`
       : "No folder passed lexical retrieval",
-    detail,
+    detail: [detail, emptyDetail].filter(Boolean).join(" "),
     actionLabel: "Run update",
     actionKind: "sync",
   };
@@ -51,41 +74,46 @@ export function buildConnectorActivationCheck(
   activation: ActivationStatus
 ): HealthCheck | null {
   const { projected, total, truncated } = activation.connectorProjection;
-  const omitted = total - projected;
+  const omitted = omittedConnectorSummary(activation);
   const observed = activation.connectors.filter(
-    ({ code }) =>
-      code !== "connector_not_configured" &&
-      code !== "target_runtime_unverifiable"
+    (connector) => classifyConnectorProof(connector) !== "notApplicable"
   );
-  if (observed.length === 0 && !truncated) {
+  const omittedObserved = omitted
+    ? omitted.passed + omitted.failed + omitted.incomplete
+    : 0;
+  if (observed.length === 0 && omittedObserved === 0 && omitted) {
     return null;
   }
   const failed = observed.filter(({ status }) => status === "failed");
   const incomplete = observed.filter(({ status }) => status !== "passed");
+  const failedCount = failed.length + (omitted?.failed ?? 0);
+  const incompleteCount =
+    incomplete.length + (omitted?.incomplete ?? 0) + (omitted?.failed ?? 0);
+  const passedCount =
+    observed.length - incomplete.length + (omitted?.passed ?? 0);
   const first = failed[0] ?? incomplete[0] ?? observed[0];
   const firstDetail = first
     ? `${first.target} / ${first.collection}: ${first.status}${first.code ? `/${first.code}` : ""}${first.remediation ? `. ${first.remediation}` : ""}`
     : null;
-  const projectionDetail = truncated
-    ? `${omitted} target/collection checks were omitted by the bounded status projection; no result is claimed for them.`
-    : null;
+  const projectionDetail = describeOmittedConnectorPairs(activation);
+  const listing = truncated ? ` (${projected} of ${total} checks listed)` : "";
   return {
     id: "connector-activation",
     title: "Connector proof",
     status:
-      failed.length > 0
+      failedCount > 0
         ? "error"
-        : incomplete.length > 0 || truncated
+        : incompleteCount > 0 || !omitted
           ? "warn"
           : "ok",
     summary:
-      failed.length > 0
-        ? `${countLabel(failed.length, "connector proof")} failed`
-        : incomplete.length > 0
-          ? `${countLabel(incomplete.length, "connector proof")} incomplete`
-          : truncated
-            ? `${projected} of ${total} connector target/collection checks projected`
-            : `${countLabel(observed.length, "connector proof")} passed`,
+      failedCount > 0
+        ? `${countLabel(failedCount, "connector proof")} failed${listing}`
+        : incompleteCount > 0
+          ? `${countLabel(incompleteCount, "connector proof")} incomplete${listing}`
+          : omitted
+            ? `${countLabel(passedCount, "connector proof")} passed${listing}`
+            : `${projected} of ${total} connector target/collection checks projected`,
     detail: [projectionDetail, firstDetail].filter(Boolean).join(" "),
   };
 }

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

@@ -9,6 +9,11 @@ import {
 
 import type { AppStatusResponse } from "../../status-model";
 
+import {
+  describeConnectorSummary,
+  omittedConnectorSummary as summarizeOmittedConnectors,
+} from "../../../core/activation-connector-health";
+import { isEmptyActivationCollection } from "../../../core/activation-empty";
 import { buildConnectorActivationCheck } from "../../activation-health";
 import { Button } from "./ui/button";
 import {
@@ -53,6 +58,7 @@ export function BootstrapStatus({
   const omittedConnectorCount =
     activation.connectorProjection.total -
     activation.connectorProjection.projected;
+  const omittedConnectorSummary = summarizeOmittedConnectors(activation);
   const connectorHealth = buildConnectorActivationCheck(activation);
   const connectorsHealthy =
     connectorHealth === null || connectorHealth.status === "ok";
@@ -147,9 +153,9 @@ export function BootstrapStatus({
         <Card className="border-border/60 bg-card/70">
           <CardHeader className="pb-3">
             <div className="flex items-center gap-2">
-              {activation.healthy && connectorsHealthy ? (
+              {activation.healthy && activation.usable && connectorsHealthy ? (
                 <CheckCircle2Icon className="size-4 text-emerald-500" />
-              ) : activation.usable ? (
+              ) : activation.usable || activation.healthy ? (
                 <ServerCogIcon className="size-4 text-amber-500" />
               ) : (
                 <AlertCircleIcon className="size-4 text-destructive" />
@@ -158,7 +164,9 @@ export function BootstrapStatus({
             </div>
             <CardDescription>
               {activation.healthy
-                ? "Lexical retrieval proven"
+                ? activation.usable
+                  ? "Lexical retrieval proven"
+                  : "No documents indexed yet"
                 : activation.usable
                   ? `Search usable in ${activation.collections.filter(({ ready }) => ready).length}/${activation.collections.length} folders`
                   : "Retrieval proof failed"}
@@ -179,7 +187,9 @@ export function BootstrapStatus({
                   <p className="text-muted-foreground text-xs">
                     {collection.ready
                       ? `Lexical passed; semantic ${collection.semanticAvailability.code}`
-                      : `${collection.remediation?.stage ?? "index"}/${collection.remediation?.code ?? "index_query_failed"}`}
+                      : isEmptyActivationCollection(collection)
+                        ? "No documents yet. Add files, then run update."
+                        : `${collection.remediation?.stage ?? "index"}/${collection.remediation?.code ?? "index_query_failed"}`}
                   </p>
                   {collection.remediation && (
                     <p className="mt-1 font-mono text-muted-foreground text-xs">
@@ -216,6 +226,9 @@ export function BootstrapStatus({
                   <p className="text-muted-foreground text-xs">
                     {omittedConnectorCount} additional target/collection checks
                     omitted from this bounded status view
+                    {omittedConnectorSummary
+                      ? ` (${describeConnectorSummary(omittedConnectorSummary)})`
+                      : ""}
                   </p>
                 )}
               </div>

package/src/serve/status.ts

@@ -14,6 +14,7 @@ import type {
 
 import { getModelsCachePath } from "../app/constants";
 import { buildContentTypeBoostStatus } from "../config/content-types";
+import { isEmptyActivationCollection } from "../core/activation-empty";
 import {
   type ActivationStatus,
   buildActivationStatus,
@@ -555,7 +556,13 @@ function buildOnboarding(
 ): AppStatusResponse["onboarding"] {
   const foldersReady = activation.collections.length > 0;
   const modelsReady = modelCheck.status === "ok";
-  const indexedReady = activation.healthy;
+  // An empty folder is not a failure, but a workspace with no documents yet
+  // has not finished its first proof.
+  const indexedReady = activation.healthy && activation.usable;
+  const readyCount = activation.collections.filter(({ ready }) => ready).length;
+  const emptyCount = activation.collections.filter(
+    isEmptyActivationCollection
+  ).length;
   const semanticStates = [
     ...new Set(
       activation.collections.map(
@@ -563,10 +570,22 @@ function buildOnboarding(
       )
     ),
   ];
-  const failedActivation = activation.collections.find(({ ready }) => !ready);
-  const activationDetail = failedActivation?.remediation
-    ? `${failedActivation.collection}: ${failedActivation.remediation.stage}/${failedActivation.remediation.code}. Run: ${failedActivation.remediation.command}`
-    : "Run the first sync to populate a searchable lexical index.";
+  const failedActivation =
+    activation.collections.find(
+      (collection) =>
+        !collection.ready && !isEmptyActivationCollection(collection)
+    ) ?? activation.collections.find(({ ready }) => !ready);
+  const activationDetail = !failedActivation?.remediation
+    ? "Run the first sync to populate a searchable lexical index."
+    : isEmptyActivationCollection(failedActivation)
+      ? `${failedActivation.collection} has no documents yet. Add files, then run: ${failedActivation.remediation.command}`
+      : `${failedActivation.collection}: ${failedActivation.remediation.stage}/${failedActivation.remediation.code}. Run: ${failedActivation.remediation.command}`;
+  const emptyNote =
+    emptyCount > 0
+      ? ` ${summarizeCount(emptyCount, "folder")} with no documents yet.`
+      : "";
+  const passedFolders =
+    emptyCount > 0 ? "Every folder with documents" : "Every folder";
 
   const steps = [
     {
@@ -600,7 +619,7 @@ function buildOnboarding(
       title: "Prove lexical retrieval",
       status: indexedReady ? "complete" : foldersReady ? "current" : "upcoming",
       detail: indexedReady
-        ? `${summarizeCount(activation.collections.length, "folder")} passed a corpus-derived lexical proof.`
+        ? `${summarizeCount(readyCount, "folder")} passed a corpus-derived lexical proof.${emptyNote}`
         : activationDetail,
       action: "sync",
     },
@@ -636,8 +655,8 @@ function buildOnboarding(
     stage: "ready",
     headline: "Workspace ready",
     detail: modelsReady
-      ? `Every folder passed lexical retrieval. Local model files are cached; semantic retrieval remains separate (${semanticStates.join(", ")}).`
-      : `Every folder passed lexical retrieval. Semantic retrieval remains an optional next step (${semanticStates.join(", ")}).`,
+      ? `${passedFolders} passed lexical retrieval.${emptyNote} Local model files are cached; semantic retrieval remains separate (${semanticStates.join(", ")}).`
+      : `${passedFolders} passed lexical retrieval.${emptyNote} Semantic retrieval remains an optional next step (${semanticStates.join(", ")}).`,
     suggestedCollections: suggestions,
     steps,
   };

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

@@ -1 +0,0 @@
-7fe15ce08a24f4dae4ac6694f62bb26d94bbc47d6abc09826f29267ace10558d  gno-browser-clipper-v2.8.3.zip