@gmickel/gno 2.5.1 → 2.7.0

package/src/cli/commands/capture.ts

@@ -4,30 +4,28 @@
  * @module src/cli/commands/capture
  */
 
-// node:fs/promises for mkdir (no Bun equivalent for recursive dir creation)
-import { mkdir } from "node:fs/promises";
-// node:path has no Bun path utilities
-import { dirname, join } from "node:path";
-
 import type {
-  CapturePlan,
+  CaptureInput,
   CaptureReceipt,
   CaptureSourceKind,
 } from "../../core/capture";
 import type { NoteCollisionPolicy } from "../../core/note-creation";
 import type { NotePresetId } from "../../core/note-presets";
+import type { RequestReceiptInfo } from "../../core/request-receipts";
 
 import { getIndexDbPath } from "../../app/constants";
 import {
-  buildCaptureReceipt,
   listCaptureDiskRelPaths,
   planCapture,
   serializeCaptureReceipt,
 } from "../../core/capture";
-import { writeCapturePlanFile } from "../../core/capture-write";
-import { withWriteLock } from "../../core/file-lock";
-import { defaultSyncService, withContentTypeRules } from "../../ingestion";
+import { publishCapture } from "../../core/capture-publish";
+import {
+  formatRequestReceiptLine,
+  localRequestLedger,
+} from "../../core/request-receipts";
 import { CliError } from "../errors";
+import { requestErrorToCli } from "./request-status";
 import { initStore } from "./shared";
 
 export interface CaptureCliOptions {
@@ -49,6 +47,7 @@ export interface CaptureCliOptions {
   sourceAuthor?: string;
   sourceDate?: string;
   sourceId?: string;
+  requestId?: string;
 }
 
 const SOURCE_KINDS = new Set<CaptureSourceKind>([
@@ -130,7 +129,7 @@ function validateCollisionPolicy(
 
 export async function capture(
   options: CaptureCliOptions
-): Promise<CaptureReceipt> {
+): Promise<CaptureReceipt & { request?: RequestReceiptInfo }> {
   const storeInit = await initStore({
     configPath: options.configPath,
     indexName: options.indexName,
@@ -160,102 +159,61 @@ export async function capture(
 
     validateCollisionPolicy(options.collisionPolicy);
     const content = await readContent(options);
-    const existingDocs = await store.listDocuments(collection.name);
-    if (!existingDocs.ok) {
-      throw new Error(existingDocs.error.message);
-    }
-    const diskRelPaths = await listCaptureDiskRelPaths(collection.path);
-    let plan: CapturePlan;
+    const input: CaptureInput = {
+      collection: collection.name,
+      content,
+      title: options.title,
+      relPath: options.path,
+      folderPath: options.folder,
+      collisionPolicy: options.collisionPolicy,
+      presetId: options.preset,
+      tags: parseTags(options.tags),
+      source: buildSource(options),
+    };
+    const ledger = localRequestLedger(getIndexDbPath(options.indexName));
     try {
-      plan = planCapture({
-        input: {
-          collection: collection.name,
-          content,
-          title: options.title,
-          relPath: options.path,
-          folderPath: options.folder,
-          collisionPolicy: options.collisionPolicy,
-          presetId: options.preset,
-          tags: parseTags(options.tags),
-          source: buildSource(options),
+      const published = await publishCapture({
+        collection,
+        store,
+        lockPath: ledger.lockPath,
+        reportSyncFailure: true,
+        config,
+        plan: async () => {
+          const existingDocs = await store.listDocuments(collection.name);
+          if (!existingDocs.ok) {
+            throw new Error(existingDocs.error.message);
+          }
+          try {
+            return planCapture({
+              input,
+              existingRelPaths: existingDocs.value.map((doc) => doc.relPath),
+              diskRelPaths: await listCaptureDiskRelPaths(collection.path),
+            });
+          } catch (error) {
+            throw new CliError(
+              "VALIDATION",
+              error instanceof Error ? error.message : String(error)
+            );
+          }
         },
-        existingRelPaths: existingDocs.value.map((doc) => doc.relPath),
-        diskRelPaths,
+        request:
+          options.requestId === undefined
+            ? undefined
+            : { ...ledger, requestId: options.requestId, input },
       });
+      return published.request
+        ? { ...published.receipt, request: published.request }
+        : published.receipt;
     } catch (error) {
-      throw new CliError(
-        "VALIDATION",
-        error instanceof Error ? error.message : String(error)
-      );
+      throw requestErrorToCli(error);
     }
-    const absPath = join(collection.path, plan.relPath);
-
-    const lockPath = join(
-      dirname(getIndexDbPath(options.indexName)),
-      ".mcp-write.lock"
-    );
-    return await withWriteLock(lockPath, async () => {
-      if (plan.openedExisting) {
-        const existingDoc = await store.getDocument(
-          collection.name,
-          plan.relPath
-        );
-        if (!existingDoc.ok) {
-          throw new Error(existingDoc.error.message);
-        }
-        return buildCaptureReceipt({
-          plan,
-          absPath,
-          docid: existingDoc.value?.docid,
-          sync: existingDoc.value
-            ? { status: "completed" }
-            : {
-                status: "skipped",
-                reason: "Existing file is not indexed yet.",
-              },
-        });
-      }
-
-      await mkdir(dirname(absPath), { recursive: true });
-      await writeCapturePlanFile(plan, absPath);
-      const syncResults = await defaultSyncService.syncFiles(
-        collection,
-        store,
-        [plan.relPath],
-        withContentTypeRules(
-          {
-            runUpdateCmd: false,
-            gitPull: false,
-          },
-          config
-        )
-      );
-      const syncResult = syncResults[0];
-      const docResult = await store.getDocument(collection.name, plan.relPath);
-      const docid = docResult.ok ? docResult.value?.docid : undefined;
-      return buildCaptureReceipt({
-        plan,
-        absPath,
-        docid: syncResult?.docid ?? docid,
-        sync:
-          syncResult?.status === "error"
-            ? {
-                status: "failed",
-                error:
-                  syncResult.errorMessage ??
-                  syncResult.errorCode ??
-                  "Unknown sync error",
-              }
-            : { status: "completed" },
-      });
-    });
   } finally {
     await store.close();
   }
 }
 
 export function formatCaptureReceipt(
-  receipt: CaptureReceipt,
+  receipt: CaptureReceipt & { request?: RequestReceiptInfo },
   options: { json?: boolean; quiet?: boolean } = {}
 ): string {
   if (options.json) {
@@ -278,5 +236,6 @@ export function formatCaptureReceipt(
   if (receipt.source.url) {
     lines.push(`Source: ${receipt.source.url}`);
   }
+  if (receipt.request) lines.push(formatRequestReceiptLine(receipt.request));
   return lines.join("\n");
 }

package/src/cli/commands/daemon.ts

@@ -3,6 +3,7 @@ import type { HttpGatewayOverrides } from "../../mcp/http-security";
 import type { BackgroundRuntimeResult } from "../../serve/background-runtime";
 import type { FindingsPassResult } from "../../serve/findings-pass";
 import type { ResidentRuntime } from "../../serve/resident-runtime";
+import type { SessionAutomationRunResult } from "../../sessions/types";
 
 import {
   enforceCollectionEgress,
@@ -17,6 +18,7 @@ import {
 import { startBackgroundRuntime } from "../../serve/background-runtime";
 import { handleResidentStatus, handleStatus } from "../../serve/routes/api";
 import { createMcpHttpGateway } from "../../serve/routes/mcp";
+import { SessionsError } from "../../sessions/types";
 
 export interface DaemonOptions extends HttpGatewayOverrides {
   configPath?: string;
@@ -67,6 +69,31 @@ export function logFindingsPassResult(
   );
 }
 
+/** Content-free: counts and reason codes only; clean no-ops stay silent. */
+export function logSessionAutomationResult(
+  result: SessionAutomationRunResult,
+  logger: DaemonLogger,
+  options: { quiet?: boolean }
+): void {
+  if (!result.ran) return;
+  if (result.outcome === "failed") {
+    logger.error(
+      `session automation ${result.profileId}: failed (${result.reason ?? "unknown"})`
+    );
+    return;
+  }
+  if (result.outcome === "up_to_date" || options.quiet) return;
+  let imported = 0;
+  let updated = 0;
+  for (const receipt of result.receipts) {
+    imported += receipt.counts.imported;
+    updated += receipt.counts.updated;
+  }
+  logger.log(
+    `session automation ${result.profileId}: ${result.outcome}${result.reason ? ` (${result.reason})` : ""}; ${imported} threads imported, ${updated} updated`
+  );
+}
+
 function formatCollectionSyncSummary(result: CollectionSyncResult): string {
   return `${result.collection}: ${result.filesAdded} added, ${result.filesUpdated} updated, ${result.filesUnchanged} unchanged, ${result.filesErrored} errors`;
 }
@@ -175,6 +202,20 @@ export async function daemon(
         quiet: options.quiet,
         verbose: options.verbose,
       }),
+    onSessionAutomationResult: (result) =>
+      logSessionAutomationResult(result, logger, { quiet: options.quiet }),
+    onSessionAutomationError: (error) => {
+      // Busy state (a run or state change in progress) is retried next tick.
+      if (error instanceof SessionsError && error.code === "SESSIONS_BUSY") {
+        if (options.verbose) {
+          logger.log("session automation: run in progress; next tick retries");
+        }
+        return;
+      }
+      logger.error(
+        `session automation tick failed: ${error instanceof SessionsError ? error.code : "runtime error"}`
+      );
+    },
     watchCallbacks: {
       onSyncStart: ({ collection, relPaths }) => {
         if (!options.quiet) {

package/src/cli/commands/doctor.ts

@@ -12,6 +12,10 @@ import { arch, platform } from "node:os";
 
 import type { Config } from "../../config/types";
 import type { ActivationStatus } from "../../core/activation-status";
+import type {
+  VectorPartitionStatus,
+  VectorRuntimeStatus,
+} from "../../store/vector/status";
 
 import { getIndexDbPath, getModelsCachePath } from "../../app/constants";
 import {
@@ -26,6 +30,7 @@ import {
   readFindingsRunStatus,
   resolveFindingsSchedule,
 } from "../../core/findings-run-state";
+import { formatVectorPartitionLines } from "../../core/vector-partition-status";
 import { getCodeChunkingStatus } from "../../ingestion/chunker";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset, resolveModelUri } from "../../llm/registry";
@@ -57,6 +62,9 @@ export interface DoctorCheck {
   details?: string[];
   /** Embedding fingerprint diagnostics for machine consumers */
   embeddingFingerprint?: EmbeddingFingerprintHealth;
+  /** Vector partitions; `retrieval` marks the one status and search use */
+  vectorPartitions?: VectorPartitionStatus[];
+  vectorRuntime?: VectorRuntimeStatus;
 }
 
 export interface EmbeddingFingerprintGroup {
@@ -261,16 +269,18 @@ function describeFingerprintGroup(group: EmbeddingFingerprintGroup): string {
 async function checkEmbeddingFingerprints(
   config: Config,
   indexName?: string
-): Promise<DoctorCheck> {
+): Promise<DoctorCheck[]> {
   const dbPath = getIndexDbPath(indexName);
   try {
     await stat(dbPath);
   } catch {
-    return {
-      name: "embedding-fingerprint",
-      status: "warn",
-      message: "Database not found. Run: gno init",
-    };
+    return [
+      {
+        name: "embedding-fingerprint",
+        status: "warn",
+        message: "Database not found. Run: gno init",
+      },
+    ];
   }
 
   const store = new SqliteAdapter();
@@ -283,12 +293,14 @@ async function checkEmbeddingFingerprints(
     config.busyTimeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS
   );
   if (!openResult.ok) {
-    return {
-      name: "embedding-fingerprint",
-      status: "warn",
-      message: `Fingerprint health unavailable: ${openResult.error.message}`,
-      details: ["Run: gno doctor --json", "Then run: gno embed"],
-    };
+    return [
+      {
+        name: "embedding-fingerprint",
+        status: "warn",
+        message: `Fingerprint health unavailable: ${openResult.error.message}`,
+        details: ["Run: gno doctor --json", "Then run: gno embed"],
+      },
+    ];
   }
 
   try {
@@ -297,12 +309,14 @@ async function checkEmbeddingFingerprints(
     const currentFingerprint = getStoredEmbeddingFingerprint(db, model);
     const statusResult = await store.getStatus({ embedModel: model });
     if (!statusResult.ok) {
-      return {
-        name: "embedding-fingerprint",
-        status: "warn",
-        message: `Fingerprint health unavailable: ${statusResult.error.message}`,
-        details: ["Run: gno embed"],
-      };
+      return [
+        {
+          name: "embedding-fingerprint",
+          status: "warn",
+          message: `Fingerprint health unavailable: ${statusResult.error.message}`,
+          details: ["Run: gno embed"],
+        },
+      ];
     }
 
     const legacyChunks =
@@ -389,13 +403,33 @@ async function checkEmbeddingFingerprints(
       }
     }
 
-    return {
+    const fingerprintCheck: DoctorCheck = {
       name: "embedding-fingerprint",
       status: hasWarnings ? "warn" : "ok",
       message,
       details: details.length > 0 ? details : undefined,
       embeddingFingerprint: health,
     };
+    const partitions = statusResult.value.vectorPartitions;
+    if (!partitions) return [fingerprintCheck];
+    const runtime = statusResult.value.vectorRuntime;
+    const partitionLines = formatVectorPartitionLines(partitions, runtime);
+    const retrieval = partitions.find((p) => p.retrieval);
+    return [
+      fingerprintCheck,
+      {
+        name: "vector-partitions",
+        status: partitionLines.length ? "warn" : "ok",
+        message: retrieval
+          ? `this runtime's retrieval uses ${retrieval.id.slice(0, 12)} (${retrieval.state}, ${retrieval.owners} chunks, ${retrieval.provenance}); ${partitions.length - 1} other partition(s)`
+          : runtime?.state === "unavailable"
+            ? `this runtime uses lexical retrieval only: ${runtime.reason}`
+            : `this runtime has not resolved a partition yet; ${partitions.length} partition(s)`,
+        details: partitionLines.length ? partitionLines.slice(1) : undefined,
+        vectorPartitions: partitions,
+        vectorRuntime: runtime,
+      },
+    ];
   } finally {
     await store.close();
   }
@@ -669,7 +703,7 @@ export async function doctor(
   checks.push(checkCodeChunking());
 
   // Embedding fingerprint freshness
-  checks.push(await checkEmbeddingFingerprints(config, options.indexName));
+  checks.push(...(await checkEmbeddingFingerprints(config, options.indexName)));
 
   // Scheduled findings pass (daemon-only, opt-in)
   checks.push(await checkFindingsPass(config, options.indexName));

package/src/cli/commands/embed.ts

@@ -7,6 +7,9 @@
 
 import type { Database } from "bun:sqlite";
 
+// node:readline/promises is the platform line-input API; Bun has no equivalent
+import { createInterface } from "node:readline/promises";
+
 import type { EmbeddingPort } from "../../llm/types";
 import type { StoreResult } from "../../store/types";
 
@@ -77,8 +80,10 @@ export interface EmbedOptions extends CliWriteLeaseOptions {
   force?: boolean;
   /** Show what would be done without embedding */
   dryRun?: boolean;
-  /** Skip confirmation prompts */
+  /** Skip confirmation prompts (never confirms a separate vector partition) */
   yes?: boolean;
+  /** Explicitly confirm building a separate vector partition */
+  newPartition?: boolean;
   /** Output as JSON */
   json?: boolean;
   /** Verbose error logging */
@@ -450,6 +455,24 @@ async function initEmbedContext(
   return { ok: true, config, modelUri, store };
 }
 
+async function confirmSeparatePartition(message: string): Promise<boolean> {
+  process.stderr.write(`${message}\n`);
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+  try {
+    const answer = await prompt.question(
+      "Build the separate partition? [y/N] "
+    );
+    return /^(?:y|yes)$/i.test(answer.trim());
+  } catch {
+    return false;
+  } finally {
+    prompt.close();
+  }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Main Command
 // ─────────────────────────────────────────────────────────────────────────────
@@ -574,7 +597,7 @@ export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
         }
         vectorIndex = vectorResult.value;
 
-        const prepared = await prepareEmbeddingBacklog({
+        const backlogDeps = {
           statsPort: stats,
           embedPort,
           vectorIndex,
@@ -582,7 +605,22 @@ export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
           collection: options.collection,
           batchSize,
           force,
-        });
+          allowNewPartition: options.newPartition,
+        };
+        let prepared = await prepareEmbeddingBacklog(backlogDeps);
+        if (
+          !prepared.ok &&
+          prepared.error.code === "VECTOR_PARTITION_FORK" &&
+          !dryRun &&
+          !options.json &&
+          !options.yes &&
+          process.stdin.isTTY &&
+          (await confirmSeparatePartition(prepared.error.message))
+        )
+          prepared = await prepareEmbeddingBacklog({
+            ...backlogDeps,
+            allowNewPartition: true,
+          });
         if (!prepared.ok)
           return { success: false, error: prepared.error.message };
         if (prepared.value.variantStore) {

package/src/cli/commands/ls.ts

@@ -14,6 +14,8 @@ import { initStore } from "./shared";
 // ─────────────────────────────────────────────────────────────────────────────
 
 export interface LsCommandOptions {
+  /** Index name (defaults to "default"). */
+  indexName?: string;
   /** Override config path */
   configPath?: string;
   /** Max results (default 20) */
@@ -111,6 +113,7 @@ export async function ls(
 
   const initResult = await initStore({
     configPath: options.configPath,
+    indexName: options.indexName,
     syncConfig: false,
   });
   if (!initResult.ok) {

package/src/cli/commands/memory.ts

@@ -24,11 +24,15 @@ import {
   type RememberInput,
   type RememberResult,
 } from "../../core/memory";
-import { writeLeasePath } from "../../core/write-lease";
+import {
+  formatRequestReceiptLine,
+  localRequestLedger,
+} from "../../core/request-receipts";
 import { LlmAdapter } from "../../llm/nodeLlamaCpp/adapter";
 import { resolveModelUri } from "../../llm/registry";
 import { createVectorIndexPort } from "../../store/vector";
 import { CliError, type CliErrorCode } from "../errors";
+import { requestErrorToCli } from "./request-status";
 import { initStore } from "./shared";
 
 /** Environment overrides for the identity defaults. */
@@ -62,6 +66,7 @@ export interface RememberCliOptions
   receipt?: string;
   derivedFrom?: string[];
   source?: string;
+  requestId?: string;
 }
 
 export interface RecallCliOptions
@@ -254,7 +259,7 @@ const MEMORY_ERROR_TO_CLI: Record<MemoryErrorCode, CliErrorCode> = {
 
 /** Map a core `MemoryError` onto the CLI error model (code carried in details). */
 export function toCliError(error: unknown): unknown {
-  if (!(error instanceof MemoryError)) return error;
+  if (!(error instanceof MemoryError)) return requestErrorToCli(error);
   return new CliError(MEMORY_ERROR_TO_CLI[error.code], error.message, {
     details: { memoryCode: error.code },
   });
@@ -322,11 +327,13 @@ async function openMemoryRuntime(
         await embedResult.value.dispose();
       }
     }
+    const ledger = localRequestLedger(getIndexDbPath(options.indexName));
     const service = new MemoryService({
       store,
       config,
       collections,
-      lockPath: writeLeasePath(getIndexDbPath(options.indexName)),
+      lockPath: ledger.lockPath,
+      requests: ledger,
       embedPort,
       vectorIndex,
     });
@@ -361,6 +368,7 @@ export async function remember(
         ? options.derivedFrom
         : undefined,
       source: options.source,
+      requestId: options.requestId,
     };
     return await runtime.service.remember(input);
   } catch (error) {
@@ -457,6 +465,7 @@ export function formatRememberResult(
     lines.push(`Sync: ${result.sync.status}`);
   }
   lines.push(`Matching: ${formatMatching(result.matching)}`);
+  if (result.request) lines.push(formatRequestReceiptLine(result.request));
   return lines.join("\n");
 }
 

package/src/cli/commands/query.ts

@@ -37,6 +37,7 @@ import {
   createVectorIndexPort,
   type VectorIndexPort,
 } from "../../store/vector";
+import { VECTOR_RUNTIME_INCOMPATIBLE } from "../../store/vector/variant-search";
 import { getGlobals } from "../program";
 import {
   createProgressRenderer,
@@ -517,6 +518,10 @@ export function formatQuery(
   }
   // Output explain to stderr if present (async but best-effort)
   outputExplainToStderr(result.data);
+  if (options.format !== "json")
+    for (const warning of result.data.meta.warnings ?? [])
+      if (warning.code === VECTOR_RUNTIME_INCOMPATIBLE)
+        process.stderr.write(`Warning: ${warning.message}\n`);
 
   // Use shared formatter for consistent output
   // Dynamic import to keep module loading fast

package/src/cli/commands/request-status.ts

@@ -0,0 +1,59 @@
+/**
+ * gno request-status: look up a write request ID before retrying it, plus
+ * the CLI mapping for request receipt errors.
+ *
+ * @module src/cli/commands/request-status
+ */
+
+import { getIndexDbPath } from "../../app/constants";
+import {
+  formatRequestStatus,
+  localRequestLedger,
+  readRequestStatus,
+  RequestReceiptError,
+  type RequestReceiptErrorCode,
+  type RequestStatusResult,
+} from "../../core/request-receipts";
+import { CliError, type CliErrorCode } from "../errors";
+
+const REQUEST_ERROR_TO_CLI: Record<RequestReceiptErrorCode, CliErrorCode> = {
+  REQUEST_ID_INVALID: "VALIDATION",
+  REQUEST_ID_CONFLICT: "VALIDATION",
+  REQUEST_EXPIRED: "VALIDATION",
+  // Accepted and still in progress elsewhere: exit 4 like lease contention.
+  REQUEST_PENDING: "BUSY",
+  REQUEST_RECOVERY_CONFLICT: "RUNTIME",
+  REQUEST_CAPACITY_EXHAUSTED: "RUNTIME",
+  REQUEST_LEDGER_UNAVAILABLE: "RUNTIME",
+};
+
+/** Map a request receipt error onto the CLI error model (code in details). */
+export function requestErrorToCli(error: unknown): unknown {
+  if (!(error instanceof RequestReceiptError)) return error;
+  return new CliError(REQUEST_ERROR_TO_CLI[error.code], error.message, {
+    details: { requestCode: error.code },
+  });
+}
+
+export async function requestStatus(options: {
+  requestId: string;
+  indexName?: string;
+}): Promise<RequestStatusResult> {
+  try {
+    return await readRequestStatus({
+      ...localRequestLedger(getIndexDbPath(options.indexName)),
+      requestId: options.requestId,
+    });
+  } catch (error) {
+    throw requestErrorToCli(error);
+  }
+}
+
+export function formatRequestStatusOutput(
+  result: RequestStatusResult,
+  options: { json?: boolean } = {}
+): string {
+  return options.json
+    ? JSON.stringify(result, null, 2)
+    : formatRequestStatus(result);
+}