@gmickel/gno 0.29.1 → 0.31.0

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)
@@ -39,6 +40,20 @@ GNO is a local knowledge engine that turns your documents into a searchable, con
 - **GNO Desktop Beta**: first mac-first desktop beta shell with deep-link routing, singleton handoff, and the same onboarding/search/edit flows as `gno serve`
 - **Desktop Onboarding Polish**: guided setup now covers folders, presets, model readiness, indexing, connectors, import preview, app tabs, file actions, and recovery without drift between web and desktop
 - **Default Preset Upgrade**: `slim-tuned` is now the built-in default, using the fine-tuned retrieval expansion model while keeping the same embed, rerank, and answer stack as `slim`
+- **Workspace UI Polish**: richer scholarly-dusk presentation across dashboard, tabs, search, ask, footer, and global styling without introducing external font or asset dependencies
+
+## What's New in v0.30
+
+- **Headless Daemon Mode**: `gno daemon` keeps your index fresh continuously without opening the Web UI
+- **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
 
@@ -144,6 +159,7 @@ gno query "ECONNREFUSED 127.0.0.1:5432" --thorough
 ```bash
 gno init ~/notes --name notes    # Point at your docs
 gno index                        # Build search index
+gno daemon                       # Keep index fresh in background (foreground process)
 gno query "auth best practices"  # Hybrid search
 gno ask "summarize the API" --answer  # AI answer with citations
 ```
@@ -174,6 +190,21 @@ Verify everything works:
 gno doctor
 ```
 
+**Windows**: current validated target is `windows-x64`. See
+[docs/WINDOWS.md](./docs/WINDOWS.md) for the support stance and packaged desktop
+beta notes.
+
+Keep an index fresh continuously without opening the Web UI:
+
+```bash
+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.)
@@ -211,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.29.1",
+  "version": "0.31.0",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/src/cli/commands/ask.ts

@@ -75,6 +75,7 @@ export async function ask(
   const initResult = await initStore({
     configPath: options.configPath,
     collection: options.collection,
+    syncConfig: false,
   });
 
   if (!initResult.ok) {

package/src/cli/commands/completion/scripts.ts

@@ -28,6 +28,7 @@ const COMMANDS = [
   "get",
   "multi-get",
   "ls",
+  "daemon",
   "serve",
   "mcp",
   "mcp serve",
@@ -330,6 +331,7 @@ function getCommandDescription(cmd: string): string {
     get: "Get document by URI",
     "multi-get": "Get multiple documents",
     ls: "List indexed documents",
+    daemon: "Start headless continuous indexing",
     serve: "Start web UI server",
     mcp: "MCP server and configuration",
     "mcp serve": "Start MCP server",

package/src/cli/commands/daemon.ts

@@ -0,0 +1,159 @@
+import type { CollectionSyncResult } from "../../ingestion";
+import type { BackgroundRuntimeResult } from "../../serve/background-runtime";
+
+import { startBackgroundRuntime } from "../../serve/background-runtime";
+
+export interface DaemonOptions {
+  configPath?: string;
+  index?: string;
+  offline?: boolean;
+  verbose?: boolean;
+  quiet?: boolean;
+  noSyncOnStart?: boolean;
+  signal?: AbortSignal;
+}
+
+export type DaemonResult =
+  | { success: true }
+  | { success: false; error: string };
+
+type DaemonLogger = {
+  log: (message: string) => void;
+  error: (message: string) => void;
+};
+
+type DaemonDeps = {
+  startBackgroundRuntime?: typeof startBackgroundRuntime;
+  logger?: DaemonLogger;
+};
+
+function formatCollectionSyncSummary(result: CollectionSyncResult): string {
+  return `${result.collection}: ${result.filesAdded} added, ${result.filesUpdated} updated, ${result.filesUnchanged} unchanged, ${result.filesErrored} errors`;
+}
+
+function createSignalPromise(
+  signal: AbortSignal | undefined,
+  logger: DaemonLogger,
+  quiet: boolean
+): Promise<void> {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+
+    const complete = (message?: string): void => {
+      signal?.removeEventListener("abort", onAbort);
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+      if (message && !quiet) {
+        logger.log(message);
+      }
+      resolve();
+    };
+
+    const onAbort = (): void => complete("Daemon stopped.");
+    const onSigint = (): void => complete("Received SIGINT. Shutting down...");
+    const onSigterm = (): void =>
+      complete("Received SIGTERM. Shutting down...");
+
+    signal?.addEventListener("abort", onAbort, { once: true });
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onSigterm);
+  });
+}
+
+export async function daemon(
+  options: DaemonOptions = {},
+  deps: DaemonDeps = {}
+): Promise<DaemonResult> {
+  const logger = deps.logger ?? {
+    log: (message: string) => {
+      console.log(message);
+    },
+    error: (message: string) => {
+      console.error(message);
+    },
+  };
+
+  const runtimeResult: BackgroundRuntimeResult = await (
+    deps.startBackgroundRuntime ?? startBackgroundRuntime
+  )({
+    configPath: options.configPath,
+    index: options.index,
+    requireCollections: true,
+    offline: options.offline,
+    watchCallbacks: {
+      onSyncStart: ({ collection, relPaths }) => {
+        if (!options.quiet) {
+          logger.log(
+            `watch sync started: ${collection} (${relPaths.length} path${relPaths.length === 1 ? "" : "s"})`
+          );
+        }
+      },
+      onSyncComplete: ({ result }) => {
+        if (!options.quiet) {
+          logger.log(formatCollectionSyncSummary(result));
+        }
+      },
+      onSyncError: ({ collection, error }) => {
+        logger.error(
+          `watch sync failed: ${collection}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      },
+    },
+  });
+  if (!runtimeResult.success) {
+    return { success: false, error: runtimeResult.error };
+  }
+
+  const { runtime } = runtimeResult;
+  try {
+    if (!options.quiet) {
+      logger.log(
+        `GNO daemon started for index "${options.index ?? "default"}" using ${runtime.config.collections.length} collection${runtime.config.collections.length === 1 ? "" : "s"}.`
+      );
+      const watchState = runtime.watchService.getState();
+      if (watchState.activeCollections.length > 0) {
+        logger.log(`watching: ${watchState.activeCollections.join(", ")}`);
+      }
+      if (watchState.failedCollections.length > 0) {
+        for (const failed of watchState.failedCollections) {
+          logger.error(`watch failed: ${failed.collection}: ${failed.reason}`);
+        }
+      }
+    }
+
+    if (!options.noSyncOnStart) {
+      if (!options.quiet) {
+        logger.log("Running initial sync...");
+      }
+      const { syncResult, embedResult } = await runtime.syncAll({
+        runUpdateCmd: true,
+        triggerEmbed: true,
+      });
+      if (!options.quiet) {
+        logger.log(
+          `sync totals: ${syncResult.totalFilesAdded} added, ${syncResult.totalFilesUpdated} updated, ${syncResult.totalFilesErrored} errors, ${syncResult.totalFilesSkipped} skipped`
+        );
+      }
+      if (!options.quiet && embedResult) {
+        logger.log(
+          `embed: ${embedResult.embedded} embedded, ${embedResult.errors} errors`
+        );
+      }
+    } else if (!options.quiet) {
+      logger.log("Skipping initial sync (--no-sync-on-start).");
+    }
+
+    await createSignalPromise(options.signal, logger, options.quiet ?? false);
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  } finally {
+    await runtime.dispose();
+  }
+}

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/get.ts

@@ -110,7 +110,10 @@ export async function get(
     return { success: false, error: parsed.error, isValidation: true };
   }
 
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }

package/src/cli/commands/graph.ts

@@ -49,7 +49,10 @@ export type GraphCommandResult =
 export async function graph(
   options: GraphOptions = {}
 ): Promise<GraphCommandResult> {
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }

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/cli/commands/links.ts

@@ -315,7 +315,10 @@ export async function linksList(
   docRef: string,
   options: LinksListOptions = {}
 ): Promise<LinksListResult> {
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }
@@ -428,7 +431,10 @@ export async function backlinks(
   docRef: string,
   options: BacklinksOptions = {}
 ): Promise<BacklinksResult> {
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }
@@ -507,7 +513,10 @@ export async function similar(
   const threshold = options.threshold ?? 0.7;
   const crossCollection = options.crossCollection ?? false;
 
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }

package/src/cli/commands/ls.ts

@@ -109,7 +109,10 @@ export async function ls(
     }
   }
 
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }

package/src/cli/commands/multi-get.ts

@@ -250,7 +250,10 @@ export async function multiGet(
   const maxBytes = options.maxBytes ?? 10_240;
   const allRefs = splitRefs(refs);
 
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }

package/src/cli/commands/query.ts

@@ -83,6 +83,7 @@ export async function query(
   const initResult = await initStore({
     configPath: options.configPath,
     collection: options.collection,
+    syncConfig: false,
   });
 
   if (!initResult.ok) {

package/src/cli/commands/search.ts

@@ -56,6 +56,7 @@ export async function search(
   const initResult = await initStore({
     configPath: options.configPath,
     collection: options.collection,
+    syncConfig: false,
   });
 
   if (!initResult.ok) {

package/src/cli/commands/shared.ts

@@ -36,6 +36,8 @@ export interface InitStoreOptions {
   indexName?: string;
   /** Filter to single collection by name */
   collection?: string;
+  /** Sync collections/contexts from config into DB on open */
+  syncConfig?: boolean;
 }
 
 /**
@@ -99,6 +101,10 @@ export async function initStore(
     return { ok: false, error: openResult.error.message };
   }
 
+  if (options.syncConfig === false) {
+    return { ok: true, store, config, collections, actualConfigPath };
+  }
+
   // Sync collections from config to DB
   const syncCollResult = await store.syncCollections(config.collections);
   if (!syncCollResult.ok) {

package/src/cli/commands/vsearch.ts

@@ -65,6 +65,7 @@ export async function vsearch(
   const initResult = await initStore({
     configPath: options.configPath,
     collection: options.collection,
+    syncConfig: false,
   });
 
   if (!initResult.ok) {

package/src/cli/program.ts

@@ -188,6 +188,7 @@ export function createProgram(): Command {
   wireGraphCommand(program);
   wireMcpCommand(program);
   wireSkillCommands(program);
+  wireDaemonCommand(program);
   wireServeCommand(program);
   wireCompletionCommand(program);
 
@@ -2038,6 +2039,31 @@ function wireGraphCommand(program: Command): void {
 // Serve Command (web UI)
 // ─────────────────────────────────────────────────────────────────────────────
 
+function wireDaemonCommand(program: Command): void {
+  program
+    .command("daemon")
+    .description("Start headless continuous indexing")
+    .option(
+      "--no-sync-on-start",
+      "skip initial sync and only watch future file changes"
+    )
+    .action(async (cmdOpts: Record<string, unknown>) => {
+      const globals = getGlobals();
+      const { daemon } = await import("./commands/daemon.js");
+      const result = await daemon({
+        configPath: globals.config,
+        index: globals.index,
+        offline: globals.offline,
+        verbose: globals.verbose,
+        quiet: globals.quiet,
+        noSyncOnStart: cmdOpts.syncOnStart === false,
+      });
+      if (!result.success) {
+        throw new CliError("RUNTIME", result.error);
+      }
+    });
+}
+
 function wireServeCommand(program: Command): void {
   program
     .command("serve")