@gmickel/gno 2.8.4 → 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.4**. 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.4"
+  "version": "2.8.5"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "2.8.4",
+  "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

@@ -406,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:**
 

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

@@ -164,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",
@@ -174,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."
+                }
+              }
             }
           }
         }

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

@@ -514,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",
@@ -524,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,11 @@ 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";
@@ -149,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");
@@ -163,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/status.ts

@@ -18,7 +18,11 @@ 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";
@@ -146,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(

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-status.ts

@@ -14,6 +14,7 @@ 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";
@@ -23,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",
@@ -89,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?: {
@@ -329,18 +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);
   // A collection with no documents gives a connector nothing to prove.
   const provable = collections.filter(
     ({ projected }) => !isEmptyActivationCollection(projected)
   );
   const allPairs = provable.flatMap((collection) =>
-    boundedTargets.map((target) => ({ collection, target }))
+    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(
@@ -377,7 +394,13 @@ async function buildConnectorStatuses(
       };
     }
   );
-  return { items, total: provable.length * sortedTargets.length };
+  return {
+    items: evaluated.slice(0, MAX_CONNECTOR_PROJECTIONS),
+    omitted: summarizeConnectorProofs(
+      evaluated.slice(MAX_CONNECTOR_PROJECTIONS)
+    ),
+    total: evaluated.length,
+  };
 }
 
 async function verifyCoalesced(
@@ -526,6 +549,9 @@ export async function buildActivationStatus(
       total: connectorStatuses.total,
       projected: connectorStatuses.items.length,
       truncated: connectorStatuses.total > connectorStatuses.items.length,
+      ...(connectorStatuses.total > connectorStatuses.items.length
+        ? { omitted: connectorStatuses.omitted }
+        : {}),
     },
   };
 }

package/src/serve/activation-health.ts

@@ -3,6 +3,11 @@
 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 {
@@ -69,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,10 @@ 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";
@@ -54,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";
@@ -221,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/browser-extension/artifacts/gno-browser-clipper-v2.8.4.zip.sha256

@@ -1 +0,0 @@
-956ba0ce42d3b72635b61ca710d7adc8599fbdf08f3e32000d979158cac432c6  gno-browser-clipper-v2.8.4.zip