@gmickel/gno 0.30.0 → 0.31.1

package/README.md

@@ -20,6 +20,7 @@ GNO is a local knowledge engine that turns your documents into a searchable, con
 
 - [Quick Start](#quick-start)
 - [Installation](#installation)
+- [Daemon Mode](#daemon-mode)
 - [Search Modes](#search-modes)
 - [Agent Integration](#agent-integration)
 - [Web UI](#web-ui)
@@ -47,6 +48,13 @@ GNO is a local knowledge engine that turns your documents into a searchable, con
 - **CLI Concurrency Hardening**: read-only commands no longer trip transient `database is locked` errors when they overlap with `gno update`
 - **Web/Desktop UI Polish**: sharper workspace styling across dashboard, tabs, search, ask, and footer surfaces
 
+## What's New in v0.31
+
+- **Windows Desktop Beta Artifact**: release flow now includes a packaged `windows-x64` desktop beta zip, not just source-level support claims
+- **Packaged Runtime Proof**: Windows desktop packaging validates bundled Bun + staged GNO runtime + FTS5 + vendored snowball + `sqlite-vec`
+- **Scoped Index Fix**: `gno index <collection>` now embeds only that collection instead of accidentally burning through unrelated backlog from other collections
+- **CLI Reporting Fix**: long embed runs now report sane durations instead of bogus sub-second summaries
+
 ### v0.24
 
 - **Structured Query Documents**: first-class multi-line query syntax using `term:`, `intent:`, and `hyde:`
@@ -182,6 +190,10 @@ Verify everything works:
 gno doctor
 ```
 
+**Windows**: current validated target is `windows-x64`, with a packaged
+desktop beta zip now published on GitHub Releases. See
+[docs/WINDOWS.md](./docs/WINDOWS.md) for support scope and validation notes.
+
 Keep an index fresh continuously without opening the Web UI:
 
 ```bash
@@ -191,6 +203,8 @@ gno daemon
 `gno daemon` runs as a foreground watcher/sync/embed process. Use `nohup`,
 launchd, or systemd if you want it supervised long-term.
 
+See also: [docs/DAEMON.md](./docs/DAEMON.md)
+
 ### Connect to AI Agents
 
 #### MCP Server (Claude Desktop, Cursor, Zed, etc.)
@@ -228,6 +242,25 @@ gno skill install --target all        # All targets
 
 ---
 
+## Daemon Mode
+
+Use `gno daemon` when you want continuous indexing without the browser or
+desktop shell open.
+
+```bash
+gno daemon
+gno daemon --no-sync-on-start
+nohup gno daemon > /tmp/gno-daemon.log 2>&1 &
+```
+
+It reuses the same watch/sync/embed runtime as `gno serve`, but stays
+headless. In v0.30 it is foreground-only and does not expose built-in
+`start/stop/status` management.
+
+[Daemon guide →](https://gno.sh/docs/DAEMON/)
+
+---
+
 ## SDK
 
 Embed GNO directly in another Bun or TypeScript app. No CLI subprocesses. No local server required.

package/package.json

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

package/src/cli/commands/doctor.ts

@@ -16,6 +16,7 @@ import { getIndexDbPath, getModelsCachePath } from "../../app/constants";
 import { getConfigPaths, isInitialized, loadConfig } from "../../config";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset } from "../../llm/registry";
+import { loadFts5Snowball } from "../../store/sqlite/fts5-snowball";
 import {
   getCustomSqlitePath,
   getExtensionLoadingMode,
@@ -221,6 +222,17 @@ async function checkSqliteExtensions(): Promise<DoctorCheck[]> {
     message: jsonAvailable ? "JSON1 available" : "JSON1 not available",
   });
 
+  // Probe vendored fts5-snowball extension
+  const snowballResult = loadFts5Snowball(db);
+  checks.push({
+    name: "fts5-snowball",
+    status: snowballResult.loaded ? "ok" : "error",
+    message: snowballResult.loaded
+      ? "fts5-snowball loaded"
+      : (snowballResult.error ?? "fts5-snowball failed to load"),
+    details: snowballResult.path ? [`Path: ${snowballResult.path}`] : undefined,
+  });
+
   // Probe sqlite-vec extension
   let sqliteVecAvailable = false;
   let sqliteVecVersion = "";

package/src/cli/commands/embed.ts

@@ -44,6 +44,8 @@ import {
 export interface EmbedOptions {
   /** Override config path */
   configPath?: string;
+  /** Restrict embedding work to a single collection */
+  collection?: string;
   /** Override model URI */
   model?: string;
   /** Batch size for embedding */
@@ -102,6 +104,7 @@ interface BatchContext {
   embedPort: EmbeddingPort;
   vectorIndex: VectorIndexPort;
   modelUri: string;
+  collection?: string;
   batchSize: number;
   force: boolean;
   showProgress: boolean;
@@ -127,10 +130,11 @@ async function processBatches(ctx: BatchContext): Promise<BatchResult> {
   while (embedded + errors < ctx.totalToEmbed) {
     // Get next batch using seek pagination (cursor-based)
     const batchResult = ctx.force
-      ? await getActiveChunks(ctx.db, ctx.batchSize, cursor)
+      ? await getActiveChunks(ctx.db, ctx.batchSize, cursor, ctx.collection)
       : await ctx.stats.getBacklog(ctx.modelUri, {
           limit: ctx.batchSize,
           after: cursor,
+          collection: ctx.collection,
         });
 
     if (!batchResult.ok) {
@@ -247,6 +251,7 @@ interface EmbedContext {
  */
 async function initEmbedContext(
   configPath?: string,
+  collection?: string,
   model?: string
 ): Promise<({ ok: true } & EmbedContext) | { ok: false; error: string }> {
   const initialized = await isInitialized(configPath);
@@ -259,6 +264,12 @@ async function initEmbedContext(
     return { ok: false, error: configResult.error.message };
   }
   const config = configResult.value;
+  if (
+    collection &&
+    !config.collections.some((candidate) => candidate.name === collection)
+  ) {
+    return { ok: false, error: `Collection not found: ${collection}` };
+  }
 
   const preset = getActivePreset(config);
   const modelUri = model ?? preset.embed;
@@ -289,7 +300,11 @@ export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
   const dryRun = options.dryRun ?? false;
 
   // Initialize config and store
-  const initResult = await initEmbedContext(options.configPath, options.model);
+  const initResult = await initEmbedContext(
+    options.configPath,
+    options.collection,
+    options.model
+  );
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }
@@ -306,8 +321,8 @@ export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
 
     // Get backlog count first (before loading model)
     const backlogResult = force
-      ? await getActiveChunkCount(db)
-      : await stats.countBacklog(modelUri);
+      ? await getActiveChunkCount(db, options.collection)
+      : await stats.countBacklog(modelUri, { collection: options.collection });
 
     if (!backlogResult.ok) {
       return { success: false, error: backlogResult.error.message };
@@ -392,6 +407,7 @@ export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
       embedPort,
       vectorIndex,
       modelUri,
+      collection: options.collection,
       batchSize,
       force,
       showProgress: !options.json,
@@ -443,19 +459,23 @@ export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
 // Helper: Get all active chunks (for --force mode)
 // ─────────────────────────────────────────────────────────────────────────────
 
-function getActiveChunkCount(db: Database): Promise<StoreResult<number>> {
+function getActiveChunkCount(
+  db: Database,
+  collection?: string
+): Promise<StoreResult<number>> {
   try {
+    const collectionClause = collection ? " AND d.collection = ?" : "";
     const result = db
       .prepare(
         `
         SELECT COUNT(*) as count FROM content_chunks c
         WHERE EXISTS (
           SELECT 1 FROM documents d
-          WHERE d.mirror_hash = c.mirror_hash AND d.active = 1
+          WHERE d.mirror_hash = c.mirror_hash AND d.active = 1${collectionClause}
         )
       `
       )
-      .get() as { count: number };
+      .get(...(collection ? [collection] : [])) as { count: number };
     return Promise.resolve(ok(result.count));
   } catch (e) {
     return Promise.resolve(
@@ -470,9 +490,11 @@ function getActiveChunkCount(db: Database): Promise<StoreResult<number>> {
 function getActiveChunks(
   db: Database,
   limit: number,
-  after?: { mirrorHash: string; seq: number }
+  after?: { mirrorHash: string; seq: number },
+  collection?: string
 ): Promise<StoreResult<BacklogItem[]>> {
   try {
+    const collectionClause = collection ? " AND d.collection = ?" : "";
     // Include title for contextual embedding
     const sql = after
       ? `
@@ -482,7 +504,7 @@ function getActiveChunks(
         FROM content_chunks c
         WHERE EXISTS (
           SELECT 1 FROM documents d
-          WHERE d.mirror_hash = c.mirror_hash AND d.active = 1
+          WHERE d.mirror_hash = c.mirror_hash AND d.active = 1${collectionClause}
         )
         AND (c.mirror_hash > ? OR (c.mirror_hash = ? AND c.seq > ?))
         ORDER BY c.mirror_hash, c.seq
@@ -495,15 +517,21 @@ function getActiveChunks(
         FROM content_chunks c
         WHERE EXISTS (
           SELECT 1 FROM documents d
-          WHERE d.mirror_hash = c.mirror_hash AND d.active = 1
+          WHERE d.mirror_hash = c.mirror_hash AND d.active = 1${collectionClause}
         )
         ORDER BY c.mirror_hash, c.seq
         LIMIT ?
       `;
 
     const params = after
-      ? [after.mirrorHash, after.mirrorHash, after.seq, limit]
-      : [limit];
+      ? [
+          ...(collection ? [collection] : []),
+          after.mirrorHash,
+          after.mirrorHash,
+          after.seq,
+          limit,
+        ]
+      : [...(collection ? [collection] : []), limit];
 
     const results = db.prepare(sql).all(...params) as BacklogItem[];
     return Promise.resolve(ok(results));

package/src/cli/commands/index-cmd.ts

@@ -71,6 +71,7 @@ export async function index(options: IndexOptions = {}): Promise<IndexResult> {
       const { embed } = await import("./embed");
       const result = await embed({
         configPath: options.configPath,
+        collection: options.collection,
         verbose: options.verbose,
       });
       if (result.success) {
@@ -95,6 +96,15 @@ export function formatIndex(
   result: IndexResult,
   options: IndexOptions
 ): string {
+  function formatDuration(seconds: number): string {
+    if (seconds < 60) {
+      return `${seconds.toFixed(1)}s`;
+    }
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}m ${secs.toFixed(0)}s`;
+  }
+
   if (!result.success) {
     return `Error: ${result.error}`;
   }
@@ -110,10 +120,12 @@ export function formatIndex(
   } else if (result.embedResult) {
     lines.push("");
     const { embedded, errors, duration } = result.embedResult;
-    const errPart = errors > 0 ? ` (${errors} errors)` : "";
     lines.push(
-      `Embedded ${embedded} chunks in ${(duration / 1000).toFixed(1)}s${errPart}`
+      `Embedded ${embedded.toLocaleString()} chunks in ${formatDuration(duration)}`
     );
+    if (errors > 0) {
+      lines.push(`${errors.toLocaleString()} chunks failed to embed.`);
+    }
   }
 
   return lines.join("\n");

package/src/store/vector/stats.ts

@@ -17,6 +17,33 @@ import { err, ok } from "../types";
  * Uses EXISTS-based queries to avoid duplicates from multiple docs sharing mirror_hash.
  */
 export function createVectorStatsPort(db: Database): VectorStatsPort {
+  function buildActiveDocumentExistsClause(collection?: string): {
+    sql: string;
+    params: string[];
+  } {
+    if (collection) {
+      return {
+        sql: `
+          EXISTS (
+            SELECT 1 FROM documents d
+            WHERE d.mirror_hash = c.mirror_hash AND d.active = 1 AND d.collection = ?
+          )
+        `,
+        params: [collection],
+      };
+    }
+
+    return {
+      sql: `
+        EXISTS (
+          SELECT 1 FROM documents d
+          WHERE d.mirror_hash = c.mirror_hash AND d.active = 1
+        )
+      `,
+      params: [],
+    };
+  }
+
   return {
     countVectors(model: string): Promise<StoreResult<number>> {
       try {
@@ -36,19 +63,18 @@ export function createVectorStatsPort(db: Database): VectorStatsPort {
       }
     },
 
-    countBacklog(model: string): Promise<StoreResult<number>> {
+    countBacklog(
+      model: string,
+      options?: { collection?: string }
+    ): Promise<StoreResult<number>> {
       try {
+        const activeDoc = buildActiveDocumentExistsClause(options?.collection);
         // Count chunks needing embedding (fast for progress display)
         // Uses EXISTS to avoid duplicates when multiple docs share mirror_hash
-        const result = db
-          .prepare(
-            `
+        const sql = `
           SELECT COUNT(*) as count
           FROM content_chunks c
-          WHERE EXISTS (
-            SELECT 1 FROM documents d
-            WHERE d.mirror_hash = c.mirror_hash AND d.active = 1
-          )
+          WHERE ${activeDoc.sql}
           AND NOT EXISTS (
             SELECT 1 FROM content_vectors v
             WHERE v.mirror_hash = c.mirror_hash
@@ -56,9 +82,10 @@ export function createVectorStatsPort(db: Database): VectorStatsPort {
               AND v.model = ?
               AND v.embedded_at >= c.created_at
           )
-        `
-          )
-          .get(model) as { count: number };
+        `;
+        const result = db.prepare(sql).get(...activeDoc.params, model) as {
+          count: number;
+        };
         return Promise.resolve(ok(result.count));
       } catch (e) {
         return Promise.resolve(
@@ -72,11 +99,16 @@ export function createVectorStatsPort(db: Database): VectorStatsPort {
 
     getBacklog(
       model: string,
-      options?: { limit?: number; after?: { mirrorHash: string; seq: number } }
+      options?: {
+        limit?: number;
+        after?: { mirrorHash: string; seq: number };
+        collection?: string;
+      }
     ): Promise<StoreResult<BacklogItem[]>> {
       try {
         const limit = options?.limit ?? 1000;
         const after = options?.after;
+        const activeDoc = buildActiveDocumentExistsClause(options?.collection);
 
         // Seek pagination: use cursor to avoid skipping items as backlog shrinks
         // Query structure changes based on whether we have a cursor
@@ -95,10 +127,7 @@ export function createVectorStatsPort(db: Database): VectorStatsPort {
               ELSE 'changed'
             END as reason
           FROM content_chunks c
-          WHERE EXISTS (
-            SELECT 1 FROM documents d
-            WHERE d.mirror_hash = c.mirror_hash AND d.active = 1
-          )
+          WHERE ${activeDoc.sql}
           AND NOT EXISTS (
             SELECT 1 FROM content_vectors v
             WHERE v.mirror_hash = c.mirror_hash
@@ -123,10 +152,7 @@ export function createVectorStatsPort(db: Database): VectorStatsPort {
               ELSE 'changed'
             END as reason
           FROM content_chunks c
-          WHERE EXISTS (
-            SELECT 1 FROM documents d
-            WHERE d.mirror_hash = c.mirror_hash AND d.active = 1
-          )
+          WHERE ${activeDoc.sql}
           AND NOT EXISTS (
             SELECT 1 FROM content_vectors v
             WHERE v.mirror_hash = c.mirror_hash
@@ -139,8 +165,16 @@ export function createVectorStatsPort(db: Database): VectorStatsPort {
         `;
 
         const params = after
-          ? [model, model, after.mirrorHash, after.mirrorHash, after.seq, limit]
-          : [model, model, limit];
+          ? [
+              model,
+              ...activeDoc.params,
+              model,
+              after.mirrorHash,
+              after.mirrorHash,
+              after.seq,
+              limit,
+            ]
+          : [model, ...activeDoc.params, model, limit];
 
         const results = db.prepare(sql).all(...params) as BacklogItem[];
         return Promise.resolve(ok(results));

package/src/store/vector/types.ts

@@ -108,11 +108,14 @@ export interface VectorStatsPort {
   countVectors(model: string): Promise<StoreResult<number>>;
 
   /** Count chunks needing embedding for a model */
-  countBacklog(model: string): Promise<StoreResult<number>>;
+  countBacklog(
+    model: string,
+    options?: { collection?: string }
+  ): Promise<StoreResult<number>>;
 
   /** Get chunks needing embedding for a model (seek pagination) */
   getBacklog(
     model: string,
-    options?: { limit?: number; after?: BacklogCursor }
+    options?: { limit?: number; after?: BacklogCursor; collection?: string }
   ): Promise<StoreResult<BacklogItem[]>>;
 }