@gmickel/gno 2.8.2 → 2.8.4

package/README.md

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

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

@@ -0,0 +1 @@
+956ba0ce42d3b72635b61ca710d7adc8599fbdf08f3e32000d979158cac432c6  gno-browser-clipper-v2.8.4.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.2"
+  "version": "2.8.4"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",
@@ -197,7 +197,15 @@
     "mammoth": "1.12.2",
     "mdast-util-from-markdown": "2.0.3",
     "mdast-util-gfm": "3.1.0",
+    "mdast-util-gfm-autolink-literal": "2.0.1",
+    "mdast-util-gfm-footnote": "2.1.0",
+    "mdast-util-gfm-strikethrough": "2.0.0",
+    "mdast-util-gfm-task-list-item": "2.0.0",
     "micromark-extension-gfm": "3.0.0",
+    "micromark-extension-gfm-autolink-literal": "2.1.0",
+    "micromark-extension-gfm-footnote": "2.1.0",
+    "micromark-extension-gfm-strikethrough": "2.1.0",
+    "micromark-extension-gfm-task-list-item": "2.1.0",
     "mime-types": "2.1.35",
     "minimatch": "10.2.6",
     "nanoid": "6.0.1",

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.
@@ -987,7 +992,10 @@ resolves to a regular file inside the workspace, at most 200,000 files), no
 file is opened, and no graph edge is created. Wiki targets match files by the workspace
 link rules; a non-Markdown target needs its extension, `.md` is optional. A
 Markdown link matches only the file at its resolved path (NFC,
-case-insensitive). A
+case-insensitive); as for wiki links, `.md` is optional, so `[x](Note)` matches
+an unindexed `Note.md`. An indexed `Note.md` (compared under the same NFC,
+Unicode-lowercase key) is not outside the index, and Markdown link resolution
+itself stays exact-path, so that link remains in `links.local-targets`. A
 target missing from the listing stays unresolved; an unreadable folder or the
 file bound makes the listing incomplete, which the `links.outside-index` rule
 message states once.
@@ -995,7 +1003,12 @@ message states once.
 The wiki link parser reads Obsidian's table-escaped alias `[[Note\|Alias]]`
 as target `Note` with alias `Alias`. Markdown link text may contain balanced
 square brackets (`[see [1]](note.md)`); a destination containing a square
-bracket is not a link.
+bracket is not a link. Markdown links follow CommonMark, as Obsidian renders
+them: a `[` escaped with a backslash (`\[clause](see section 4)`) opens no
+link, and an inline destination with an unescaped space is plain text unless
+it is wrapped in angle brackets. `[x](<my note.md>)` and `[x](my%20note.md)`
+both link to `my note.md`; a link title (`[x](note.md "Title")`) is not part
+of the target.
 
 The JSON contract is versioned as `gno://schemas/audit-report@1.0`. Finding IDs
 are stable SHA-256 identities derived from rule, normalized subject/location,
@@ -1472,6 +1485,33 @@ individual virtual document. The closed `record.adapter` identity contains the
 adapter ID, version, and configuration fingerprint. `get` and `multi-get`
 preserve the same fields.
 
+Every file is indexed under the per-file budget `conversion.timeoutMs`
+(default 60000) and `conversion.maxMemoryMb` (default half of physical memory,
+at least 2048; process resident memory). Conversion and every post-conversion
+phase (metadata, code regions, change-journal structure, chunking, link
+extraction) run in one worker per process, one file at a time; the worker is
+terminated at either limit, mid-phase, and replaced for the next file.
+Database reads and writes stay on the main thread. A standalone compiled
+executable, which cannot start the worker, runs the phases in a child process
+of itself (internal environment flag) under the same limits; the child's
+resident memory counts toward `conversion.maxMemoryMb` (Linux `/proc`, `ps`
+elsewhere; time only on Windows). A processor that cannot start fails the file
+with `ISOLATION_UNAVAILABLE`; nothing is prepared without the budget. The
+child is SIGKILLed on process exit, SIGTERM, SIGINT (via the CLI's exit
+path) and resident shutdown; on Linux it also carries a parent-death signal,
+so it dies with a SIGKILLed parent, and elsewhere it exits at its next step
+once its parent is gone.
+A file over either limit is recorded with error code `TIMEOUT` or
+`MEMORY_LIMIT` (the message names the running phase), stays unindexed, and is
+retried by the next sync; the rest of the run continues. `update` and `index` always print such a
+file in terminal output as `[CODE] <relPath>: <message>` (other per-file
+errors stay `--verbose` only), and write
+`Still converting <collection>/<relPath> after <n>s (budget <m>s)` to stderr
+once a file has been processing for 10 seconds or half its budget, whichever
+is sooner.
+`gno status` lists stopped files under "Stopped at conversion budget" in
+terminal output (JSON output is unchanged).
+
 File/export adapter iteration has a 60-second deadline in addition to the byte,
 record, metadata, and total-character caps. A partial import that retains valid
 siblings exits successfully but is never silent: terminal output includes the
@@ -2976,14 +3016,22 @@ misconfigured `findings` block (see [Daemon Mode](../docs/DAEMON.md#scheduled-fi
 The `embedding-fingerprint` check is additive doctor-only diagnostics. It uses
 the active embed model and stored vector dimensions to report the current
 freshness fingerprint, pending/stale chunks, legacy empty-fingerprint vectors,
-and stored fingerprint groups. Stale, legacy, and mixed groups are warnings;
+and stored fingerprint groups. On an index with an activated vector partition
+for the embed model (every index `gno embed` wrote since 2.7), the groups are
+that partition with its current chunk count and there are no legacy vectors;
+legacy `content_vectors` groups are read only before any partition activates.
+Stale, legacy, and mixed groups are warnings;
 recover with `gno embed`, or `gno embed --force` if vectors still look stale.
 
 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.
@@ -3988,7 +4036,10 @@ gno similar <doc> [-n, --limit <num>] [--threshold <num>] [--cross-collection] [
 
 - Finds documents semantically similar to the source document
 - Requires embeddings to be generated (`gno embed`)
-- Uses average document embedding for comparison
+- Source vector: the stored vector of the document's first chunk (the
+  lowest-seq chunk whose vector is current), read from the active vector
+  partition. `gno_similar` (MCP), `GET /api/doc/:id/similar` (REST) and graph
+  similarity edges use the same rule, so scores match across surfaces
 - By default, limits results to same collection
 
 **Output (JSON):**
@@ -4203,6 +4254,9 @@ gno changes --follow --jsonl [--cursor <cursor>] [--collection <name>]
   old/new identity and hash snapshots, normalized structural deltas, pagination,
   cursor-expiry, and retention-truncation disclosure.
 - The journal never returns source bodies.
+- Link additions and removals in `structureDelta.links` are recorded only for
+  Markdown sources, matching link extraction; content changes of other
+  documents (code, text, converted files, records) are still journaled.
 
 **Follow mode (`--follow --jsonl`)** streams journal events as they land and is
 the durable automation input for consumers that resume across restarts.
@@ -4444,6 +4498,21 @@ gno serve --detach --stop
 
 ---
 
+#### Config reload while running
+
+A running `gno serve` or `gno daemon` re-reads its config file before each
+request (REST, Web UI, HTTP MCP, daemon status) and every 2 seconds, and adopts
+changes to `collections` and `contexts` made by the CLI (`gno collection
+add/remove`) or by hand: status, MCP `gno_status`, the watcher and search scope
+follow without a restart. A newly added collection is watched from then on; its
+existing files are indexed by `gno update` (or the next start's initial sync).
+An adoption that changes the collection set or policies moves the egress policy
+epoch as a REST collection change does. The checks are the sessions config
+refresh's: an unreadable config file answers an error (`500`, sessions code
+`SESSIONS_RUNTIME_FAILURE`), never the stale config, and a config bound to
+another index is refused. Other settings (models, gateway, sessions sources
+outside the sessions routes) keep their restart behaviour.
+
 ### gno daemon
 
 Start a headless long-running watcher process for continuous indexing.
@@ -4483,6 +4552,8 @@ is blocked.
 
 - Opens DB once at startup
 - Loads config and requires at least one configured collection
+- Follows collection edits to the config file while running (see
+  [Config reload](#config-reload-while-running))
 - Starts the same watcher + embed scheduler used by `gno serve`
 - Exact contained eligible paths always use targeted content-hash sync.
   Ambiguous temp/directory/missing-name/recursive-delete events use bounded,

package/spec/mcp.md

@@ -2188,12 +2188,11 @@ Find semantically similar documents using vector embeddings.
 
 **Algorithm:**
 
-1. Get all chunks for the source document
-2. Retrieve each chunk's stored embedding from the active vector partition (legacy `content_vectors` only before any partition activates); no model is loaded
-3. Compute average embedding across all chunks
-4. Search for nearest neighbors using sqlite-vec
-5. Exclude self and filter by collection if not crossCollection
-6. Return top N similar documents with scores
+1. Take the stored vector of the source document's first chunk (the lowest-seq chunk whose vector is current) from the active vector partition (legacy `content_vectors` only before any partition activates); no model is loaded. This is the same source vector `gno similar`, `GET /api/doc/:id/similar` and graph similarity edges use, so scores match across surfaces
+2. Normalize it to unit length
+3. Search for nearest neighbors using sqlite-vec
+4. Exclude self and filter by collection if not crossCollection
+5. Return top N similar documents with scores
 
 **Errors:**
 

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": {
@@ -229,8 +235,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",

package/src/cli/commands/daemon.ts

@@ -16,6 +16,7 @@ import {
   resolveHttpGatewayConfig,
 } from "../../mcp/http-security";
 import { startBackgroundRuntime } from "../../serve/background-runtime";
+import { refreshResidentConfig } from "../../serve/resident-request";
 import { handleResidentStatus, handleStatus } from "../../serve/routes/api";
 import { createMcpHttpGateway } from "../../serve/routes/mcp";
 import { SessionsError } from "../../sessions/types";
@@ -106,6 +107,8 @@ export const authorizeDaemonStatus = async (
 ): Promise<Response> => {
   const authorization = await gateway.security.authorize(request, server);
   if (!authorization.ok) return authorization.response;
+  const refreshFailure = await refreshResidentConfig(runtime);
+  if (refreshFailure) return refreshFailure;
   try {
     enforceCollectionEgress({
       collections: runtime.config.collections,
@@ -132,13 +135,15 @@ export const authorizeDaemonStatus = async (
   }
 };
 
-export function handleDaemonAppStatus(
+export async function handleDaemonAppStatus(
   runtime: ResidentRuntime,
   host: string
-): Promise<Response> | Response {
+): Promise<Response> {
   if (!isHttpGatewayLoopbackBind(host)) {
     return new Response(null, { status: 404 });
   }
+  const refreshFailure = await refreshResidentConfig(runtime);
+  if (refreshFailure) return refreshFailure;
   return handleStatus(runtime.ctxHolder.current, {
     getResidentStatus: () => runtime.getStatus(),
   });

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

@@ -6,6 +6,7 @@ import type { StorePort } from "../../store/types";
 import type { DoctorCheck } from "./doctor";
 
 import { getIndexDbPath, getModelsCachePath } from "../../app/constants";
+import { isEmptyActivationCollection } from "../../core/activation-empty";
 import { buildActivationStatus } from "../../core/activation-status";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset } from "../../llm/registry";
@@ -75,28 +76,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 +139,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],
   };
 }
 

package/src/cli/commands/doctor.ts

@@ -31,6 +31,7 @@ import {
   resolveFindingsSchedule,
 } from "../../core/findings-run-state";
 import { formatVectorPartitionLines } from "../../core/vector-partition-status";
+import { getEmbeddingFingerprint } from "../../embed/fingerprint";
 import { getCodeChunkingStatus } from "../../ingestion/chunker";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset, resolveModelUri } from "../../llm/registry";
@@ -42,6 +43,8 @@ import {
   getLoadAttempts,
 } from "../../store/sqlite/setup";
 import { getStoredEmbeddingFingerprint } from "../../store/vector/freshness";
+import { currentOwnerCount } from "../../store/vector/runtime-compat";
+import { storedVectorPartition } from "../../store/vector/status";
 import {
   buildDoctorActivation,
   checkConnectorActivation,
@@ -52,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;
@@ -319,10 +323,14 @@ async function checkEmbeddingFingerprints(
       ];
     }
 
-    const legacyChunks =
-      db
-        .query<{ count: number }, [string]>(
-          `
+    // An index embedded since 2.7 keeps its vectors in the active partition;
+    // legacy `content_vectors` count only before any partition activates.
+    const partition = storedVectorPartition(db, model);
+    const legacyChunks = partition
+      ? 0
+      : (db
+          .query<{ count: number }, [string]>(
+            `
           SELECT COUNT(*) as count
           FROM content_vectors v
           JOIN content_chunks c
@@ -336,12 +344,23 @@ async function checkEmbeddingFingerprints(
                 AND d.active = 1
             )
         `
-        )
-        .get(model)?.count ?? 0;
-
-    const groups = db
-      .query<{ model: string; fingerprint: string; count: number }, []>(
-        `
+          )
+          .get(model)?.count ?? 0);
+
+    const groups = partition
+      ? [
+          {
+            model,
+            fingerprint: getEmbeddingFingerprint({
+              modelUri: model,
+              dimensions: partition.dimensions,
+            }),
+            count: currentOwnerCount(db, partition.partitionId),
+          },
+        ]
+      : db
+          .query<{ model: string; fingerprint: string; count: number }, []>(
+            `
         SELECT
           v.model as model,
           v.embed_fingerprint as fingerprint,
@@ -358,18 +377,18 @@ async function checkEmbeddingFingerprints(
         GROUP BY v.model, v.embed_fingerprint
         ORDER BY count DESC, v.model ASC, v.embed_fingerprint ASC
       `
-      )
-      .all()
-      .map((group) => ({
-        model: group.model,
-        fingerprint: group.fingerprint,
-        count: group.count,
-        current:
-          group.model === model && group.fingerprint === currentFingerprint,
-        legacy: group.fingerprint === "",
-      }));
-
-    const mixedGroups = groups.length;
+          )
+          .all();
+    const fingerprintGroups = groups.map((group) => ({
+      model: group.model,
+      fingerprint: group.fingerprint,
+      count: group.count,
+      current:
+        group.model === model && group.fingerprint === currentFingerprint,
+      legacy: group.fingerprint === "",
+    }));
+
+    const mixedGroups = fingerprintGroups.length;
     const pendingChunks = statusResult.value.embeddingBacklog;
     const hasWarnings =
       pendingChunks > 0 || legacyChunks > 0 || mixedGroups > 1;
@@ -380,7 +399,7 @@ async function checkEmbeddingFingerprints(
       pendingChunks,
       legacyChunks,
       mixedGroups,
-      groups,
+      groups: fingerprintGroups,
     };
 
     const message =
@@ -392,7 +411,7 @@ async function checkEmbeddingFingerprints(
     if (hasWarnings) {
       details.push("Run: gno embed");
       details.push("If vectors still look stale, run: gno embed --force");
-      for (const group of groups) {
+      for (const group of fingerprintGroups) {
         const label = describeFingerprintGroup(group);
         const fingerprint = group.legacy
           ? "(empty)"
@@ -736,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/index-cmd.ts

@@ -28,7 +28,11 @@ import {
   withContentTypeRules,
 } from "../../ingestion";
 import { type EmbedResult, embedStageOutcome } from "./embed";
-import { formatSyncResultLines, initStore } from "./shared";
+import {
+  formatSyncResultLines,
+  initStore,
+  reportSlowConversion,
+} from "./shared";
 
 /**
  * Options for index command.
@@ -202,7 +206,11 @@ export async function index(options: IndexOptions = {}): Promise<IndexResult> {
           collections,
           store,
           withContentTypeRules(
-            { gitPull: options.gitPull, runUpdateCmd: true },
+            {
+              gitPull: options.gitPull,
+              runUpdateCmd: true,
+              onSlowConversion: reportSlowConversion,
+            },
             config
           )
         );

package/src/cli/commands/links.ts

@@ -587,21 +587,17 @@ export async function similar(
     }
     const db = store.getRawDb();
 
-    // Stored vector of the document's first chunk, from the active partition
+    // Similarity source vector (first chunk, unit length), active partition
     const {
-      readStoredDocumentVectors,
+      readSimilaritySourceVectors,
       resolveStoredVectorSource,
       similarityHitDocuments,
       storedVectorSearchOptions,
     } = await import("../../store/vector/stored-vectors.js");
     const source = resolveStoredVectorSource(db, modelPreset.embed);
-    const [embedding] =
-      readStoredDocumentVectors(
-        db,
-        source,
-        [{ id: doc.id, mirrorHash: doc.mirrorHash }],
-        { firstChunkOnly: true }
-      ).get(doc.id) ?? [];
+    const embedding = readSimilaritySourceVectors(db, source, [
+      { id: doc.id, mirrorHash: doc.mirrorHash },
+    ]).get(doc.id);
 
     if (!embedding) {
       return {
@@ -610,20 +606,7 @@ export async function similar(
         isValidation: true,
       };
     }
-
-    // Normalize embedding for cosine similarity
     const dimensions = embedding.length;
-    let norm = 0;
-    for (let i = 0; i < dimensions; i++) {
-      const val = embedding[i] ?? 0;
-      norm += val * val;
-    }
-    norm = Math.sqrt(norm);
-    if (norm > 0) {
-      for (let i = 0; i < dimensions; i++) {
-        embedding[i] = (embedding[i] ?? 0) / norm;
-      }
-    }
 
     // Create vector index port for search
     const { createVectorIndexPort } =

package/src/cli/commands/shared.ts

@@ -6,7 +6,7 @@
  */
 
 import type { Collection, Config } from "../../config/types";
-import type { SyncResult } from "../../ingestion";
+import type { SlowConversionEvent, SyncResult } from "../../ingestion";
 import type { SearchResults } from "../../pipeline/types";
 
 import {
@@ -20,6 +20,7 @@ import {
   loadConfig,
   writeConfigWarningsToStderr,
 } from "../../config";
+import { BUDGET_ERROR_CODES } from "../../ingestion/file-processor";
 import { SqliteAdapter } from "../../store/sqlite/adapter";
 import { assertCliSessionBinding } from "../session-binding";
 
@@ -164,6 +165,21 @@ export function decorateSearchResultsForIndex(
   };
 }
 
+/**
+ * Name a file whose conversion is still running past the notice threshold,
+ * so an operator can see which file a slow run is working on (stderr, so
+ * JSON output on stdout stays parseable).
+ */
+export function reportSlowConversion(event: SlowConversionEvent): void {
+  process.stderr.write(
+    `Still converting ${event.collection}/${event.relPath} after ${formatSeconds(event.elapsedMs)} (budget ${formatSeconds(event.budgetMs)})\n`
+  );
+}
+
+/** Seconds with one decimal below ten seconds, whole seconds above. */
+const formatSeconds = (ms: number): string =>
+  ms < 10_000 ? `${(ms / 1000).toFixed(1)}s` : `${Math.round(ms / 1000)}s`;
+
 /**
  * Format sync result lines (shared between update and index commands).
  */
@@ -194,6 +210,15 @@ export function formatSyncResultLines(
     if (c.filesErrored > 0) {
       lines.push(`  ${c.filesErrored} errors`);
     }
+    // A file stopped at its conversion budget is always named, not only in
+    // verbose output: it stays unindexed until a later run finishes it.
+    if (!options.verbose) {
+      for (const err of c.errors) {
+        if (BUDGET_ERROR_CODES.has(err.code)) {
+          lines.push(`    [${err.code}] ${err.relPath}: ${err.message}`);
+        }
+      }
+    }
     if (c.filesMarkedInactive > 0) {
       lines.push(`  ${c.filesMarkedInactive} marked inactive`);
     }