@gmickel/gno 2.11.0 → 2.12.0

package/src/cli/commands/cleanup.ts

@@ -6,7 +6,7 @@
  * @module src/cli/commands/cleanup
  */
 
-import type { CleanupStats } from "../../store/types";
+import type { CleanupStats, StaleCollection } from "../../store/types";
 
 import { getIndexDbPath } from "../../app/constants";
 import { isInitialized, loadConfig } from "../../config";
@@ -20,14 +20,26 @@ export interface CleanupOptions {
   configPath?: string;
   /** Index name */
   indexName?: string;
+  /** Called with the collections about to be deleted, before deleting them. */
+  onDropping?: (collections: StaleCollection[]) => void;
 }
 
 /**
  * Result of cleanup command.
  */
 export type CleanupResult =
-  | { success: true; stats: CleanupStats }
-  | { success: false; error: string };
+  | {
+      success: true;
+      stats: CleanupStats;
+      /** Indexed collections the config omits, deleted by this cleanup. */
+      droppedCollections: StaleCollection[];
+    }
+  | {
+      success: false;
+      error: string;
+      /** Collections already deleted when a later step failed. */
+      droppedCollections?: StaleCollection[];
+    };
 
 /**
  * Execute gno cleanup command.
@@ -64,17 +76,32 @@ export async function cleanup(
   try {
     // Drop collections no longer in the config first (their documents follow
     // by cascade), so their content, chunks and vectors count as orphans.
-    const syncResult = await store.syncCollections(config.collections);
+    // This is the explicit removal path; it names what it deletes.
+    const stale = await store.listStaleCollections(
+      config.collections.map(({ name }) => name)
+    );
+    if (!stale.ok) {
+      return { success: false, error: stale.error.message };
+    }
+    const droppedCollections = stale.value;
+    if (droppedCollections.length > 0) options.onDropping?.(droppedCollections);
+    const syncResult = await store.syncCollections(config.collections, {
+      remove: "stale",
+    });
     if (!syncResult.ok) {
       return { success: false, error: syncResult.error.message };
     }
 
     const cleanupResult = await store.cleanupOrphans();
     if (!cleanupResult.ok) {
-      return { success: false, error: cleanupResult.error.message };
+      return {
+        success: false,
+        error: cleanupResult.error.message,
+        droppedCollections,
+      };
     }
 
-    return { success: true, stats: cleanupResult.value };
+    return { success: true, stats: cleanupResult.value, droppedCollections };
   } finally {
     await store.close();
   }
@@ -118,3 +145,16 @@ export function formatCleanup(result: CleanupResult): string {
 
   return lines.join("\n");
 }
+
+/** Lines naming the collections cleanup is about to delete. */
+export function formatDroppingCollections(
+  collections: readonly StaleCollection[]
+): string {
+  return [
+    "Deleting collections not in this config:",
+    ...collections.map(
+      (c) =>
+        `  ${c.name}: ${c.documents} ${c.documents === 1 ? "document" : "documents"}`
+    ),
+  ].join("\n");
+}

package/src/cli/commands/collection/remove.ts

@@ -19,6 +19,7 @@ export async function collectionRemove(
     configPath: options.configPath,
     indexName: options.indexName,
     syncConfig: false,
+    allowStaleCollections: true,
     allowEmptyCollections: true,
   });
   if (!initialized.ok) {

package/src/cli/commands/collection/rename.ts

@@ -23,6 +23,7 @@ export async function collectionRename(
     configPath: options.configPath,
     indexName: options.indexName,
     syncConfig: false,
+    allowStaleCollections: true,
     allowEmptyCollections: true,
   });
   if (!initialized.ok) {

package/src/cli/commands/doctor.ts

@@ -33,6 +33,7 @@ import {
 import { formatVectorPartitionLines } from "../../core/vector-partition-status";
 import { getEmbeddingFingerprint } from "../../embed/fingerprint";
 import { getCodeChunkingStatus } from "../../ingestion/chunker";
+import { checkCollectionRoots } from "../../ingestion/source-availability/root";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset, resolveModelUri } from "../../llm/registry";
 import { SqliteAdapter } from "../../store/sqlite/adapter";
@@ -739,6 +740,37 @@ export async function checkFindingsPass(
   };
 }
 
+/** Configured collection roots that are missing or unreadable right now. */
+export async function checkCollectionRootAccess(
+  config: Config
+): Promise<DoctorCheck> {
+  const name = "collection-roots";
+  const errors = await checkCollectionRoots(config.collections);
+  const unavailable = config.collections.flatMap((collection) => {
+    const error = errors[collection.name];
+    return error ? [{ collection, error }] : [];
+  });
+  if (unavailable.length === 0) {
+    return {
+      name,
+      status: "ok",
+      message: `${config.collections.length} collection root(s) available`,
+    };
+  }
+  return {
+    name,
+    status: "warn",
+    message: `${unavailable.length} collection root(s) missing or unreadable: ${unavailable.map(({ collection }) => collection.name).join(", ")}`,
+    details: [
+      ...unavailable.map(
+        ({ collection, error }) =>
+          `${collection.name}: ${collection.path} [${error.code}] ${error.message}`
+      ),
+      "Reconnect the drive or restore the folder; if it moved, change the collection's path in the config, then run: gno update",
+    ],
+  };
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Implementation
 // ─────────────────────────────────────────────────────────────────────────────
@@ -779,6 +811,10 @@ export async function doctor(
   // Code chunking capability
   checks.push(checkCodeChunking());
 
+  // Collection roots, checked now (documents stay indexed while one is away)
+  const rootsCheck = await checkCollectionRootAccess(config);
+  checks.push(rootsCheck);
+
   // Embedding fingerprint freshness
   checks.push(...(await checkEmbeddingFingerprints(config, options.indexName)));
 
@@ -801,6 +837,7 @@ export async function doctor(
   return {
     healthy:
       !hasErrors &&
+      rootsCheck.status === "ok" &&
       activation.healthy &&
       isConnectorActivationComplete(activation),
     checks,

package/src/cli/commands/mcp/paths.ts

@@ -12,6 +12,7 @@ import type { ConnectorWorkspaceEnvironment } from "../../../core/connector-envi
 
 import { resolveDirs } from "../../../app/constants";
 import { assertValidIndexName } from "../../../app/index-name";
+import { modulePath } from "../../../core/module-path";
 import { getCurrentGnoEntrypoint } from "../../../core/runtime-entrypoint";
 import {
   DEFAULT_MCP_TOOL_PROFILE,
@@ -459,7 +460,7 @@ export function resolveLaunchPaths(): {
   entrypoint: LaunchPath;
 } {
   const entrypoint = getCurrentGnoEntrypoint();
-  if (isBunfsPath(import.meta.path)) {
+  if (isBunfsPath(modulePath(import.meta))) {
     return {
       bun: { path: process.execPath, pinned: false },
       entrypoint: { path: entrypoint, pinned: false },

package/src/cli/commands/setup-semantic.ts

@@ -21,6 +21,7 @@ import type { FolderSetupReceipt } from "../../core/setup-receipt";
 import { VERSION } from "../../app/constants";
 import { canonicalizeIndexName } from "../../app/index-name";
 import { withWriteLock } from "../../core/file-lock";
+import { moduleDir } from "../../core/module-path";
 import {
   setupFingerprint,
   setupRootFingerprint,
@@ -427,7 +428,11 @@ function createSemanticReceipt(
 async function defaultSpawnWorker(
   receipt: SetupSemanticReceipt
 ): Promise<SpawnedSemanticWorker> {
-  const workerPath = join(import.meta.dir, "..", "setup-semantic-worker.ts");
+  const workerPath = join(
+    moduleDir(import.meta),
+    "..",
+    "setup-semantic-worker.ts"
+  );
   const descriptor = openSync(receipt.logPath, "a", 0o600);
   try {
     const child = Bun.spawn({

package/src/cli/commands/shared.ts

@@ -22,7 +22,10 @@ import {
 } from "../../config";
 import { tracePhase } from "../../core/phase-trace";
 import { BUDGET_ERROR_CODES } from "../../ingestion/file-processor";
-import { SqliteAdapter } from "../../store/sqlite/adapter";
+import {
+  SqliteAdapter,
+  staleCollectionsMessage,
+} from "../../store/sqlite/adapter";
 import { assertCliSessionBinding } from "../session-binding";
 
 /**
@@ -53,6 +56,10 @@ export interface InitStoreOptions {
   syncConfig?: boolean;
   /** Permit management commands that only need an existing index database */
   allowEmptyCollections?: boolean;
+  /** Open without syncing even when the index holds collections the config
+   * omits: config mutations report them through their own sync, and a
+   * connector proof reads one collection through a subset config. */
+  allowStaleCollections?: boolean;
 }
 
 /**
@@ -132,7 +139,25 @@ export async function initStore(
     return { ok: false, error: openResult.error.message };
   }
 
+  if (options.syncConfig === false && options.allowStaleCollections) {
+    return { ok: true, store, config, collections, actualConfigPath };
+  }
   if (options.syncConfig === false) {
+    // Reads skip the sync but must not search collections another config
+    // indexed; they fail the same way a sync would.
+    const stale = await store.listStaleCollections(
+      config.collections.map(({ name }) => name)
+    );
+    const indexed = stale.ok ? stale.value.filter((c) => c.documents > 0) : [];
+    if (!stale.ok || indexed.length > 0) {
+      await store.close();
+      return {
+        ok: false,
+        error: stale.ok
+          ? staleCollectionsMessage(indexed)
+          : stale.error.message,
+      };
+    }
     return { ok: true, store, config, collections, actualConfigPath };
   }
 

package/src/cli/commands/skill/paths.ts

@@ -11,6 +11,11 @@ import { existsSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, normalize, relative, sep } from "node:path";
 
+import {
+  harnessConfigDirFromEnv,
+  type HarnessId,
+} from "../agents/harnesses.js";
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Environment Variables
 // ─────────────────────────────────────────────────────────────────────────────
@@ -84,6 +89,11 @@ interface TargetPathConfig {
   userBase: string; // e.g., ".claude" (joined with homedir) or ".config/opencode"
   skillsSubdir: string; // e.g., "skills" or "skill"
   envVar: string;
+  /**
+   * Harness whose config-dir env var (CLAUDE_CONFIG_DIR, CODEX_HOME) replaces
+   * the user base, resolved exactly as `gno agents` does.
+   */
+  configDirHarness?: HarnessId;
 }
 
 const TARGET_CONFIGS: Record<SkillTarget, TargetPathConfig> = {
@@ -92,12 +102,14 @@ const TARGET_CONFIGS: Record<SkillTarget, TargetPathConfig> = {
     userBase: ".claude",
     skillsSubdir: "skills",
     envVar: ENV_CLAUDE_SKILLS_DIR,
+    configDirHarness: "claude",
   },
   codex: {
     projectBase: ".codex",
     userBase: ".codex",
     skillsSubdir: "skills",
     envVar: ENV_CODEX_SKILLS_DIR,
+    configDirHarness: "codex",
   },
   opencode: {
     projectBase: ".opencode",
@@ -150,8 +162,14 @@ export function resolveSkillPaths(opts: SkillPathOptions): SkillPaths {
   let base: string;
 
   if (scope === "user") {
-    const home = homeDir ?? process.env[ENV_SKILLS_HOME_OVERRIDE] ?? homedir();
-    base = join(home, config.userBase);
+    // Any home override (option or env) is an isolation request and
+    // suppresses the harness config-dir env vars, as in `gno agents`.
+    const explicitHome = homeDir ?? process.env[ENV_SKILLS_HOME_OVERRIDE];
+    const configDir =
+      explicitHome === undefined && config.configDirHarness
+        ? harnessConfigDirFromEnv(config.configDirHarness)
+        : undefined;
+    base = configDir ?? join(explicitHome ?? homedir(), config.userBase);
   } else {
     const projectRoot = cwd ?? process.cwd();
     base = join(projectRoot, config.projectBase);

package/src/cli/commands/status.ts

@@ -9,7 +9,7 @@ import type { ContentTypeBoostStatus } from "../../config/content-types";
 import type { ActivationStatus } from "../../core/activation-status";
 import type { MemoryStatus } from "../../core/memory-diagnostics";
 import type { BackgroundIssue } from "../../serve/status-model";
-import type { IndexStatus } from "../../store/types";
+import type { IndexStatus, StaleCollection } from "../../store/types";
 
 import { getIndexDbPath, getModelsCachePath } from "../../app/constants";
 import {
@@ -33,6 +33,10 @@ import {
 } from "../../core/memory-diagnostics";
 import { formatVectorPartitionLines } from "../../core/vector-partition-status";
 import { BUDGET_ERROR_CODES } from "../../ingestion/file-processor";
+import {
+  checkCollectionRoots,
+  type CollectionRootError,
+} from "../../ingestion/source-availability/root";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset, resolveModelUri } from "../../llm/registry";
 import { getConnectorVerificationTargets } from "../../serve/connectors";
@@ -80,6 +84,10 @@ export type StatusResult =
       runtimeIssues?: RuntimeIssue[];
       /** Files whose latest conversion stopped at the per-file budget. */
       budgetStops: BudgetStop[];
+      /** Indexed collections this config does not list (kept until cleanup). */
+      staleCollections?: StaleCollection[];
+      /** Configured collections whose root is missing or unreadable now. */
+      rootErrors?: Record<string, CollectionRootError>;
     }
   | { success: false; error: string };
 
@@ -91,6 +99,18 @@ export interface BudgetStop {
   message: string;
 }
 
+/** Indexed collections the config omits; an unreadable list is not fatal. */
+async function collectStaleCollections(
+  store: SqliteAdapter,
+  configured: string[]
+): Promise<StaleCollection[]> {
+  const stale = await store.listStaleCollections(configured);
+  return stale.ok ? stale.value.filter((c) => c.documents > 0) : [];
+}
+
+const STALE_COLLECTIONS_HINT =
+  'not in this config; add them back, or run "gno cleanup" to delete their index data';
+
 /** Most recent ingest errors inspected for budget stops. */
 const BUDGET_STOP_SCAN_LIMIT = 100;
 /** Most budget stops listed in status output. */
@@ -164,12 +184,14 @@ function connectorProjectionLine(activation: ActivationStatus): string | null {
 
 function isStatusHealthy(
   indexStatus: IndexStatus,
-  activation: ActivationStatus
+  activation: ActivationStatus,
+  rootErrors: Record<string, CollectionRootError> = {}
 ): boolean {
   return (
     indexStatus.healthy &&
     activation.healthy &&
-    isConnectorActivationComplete(activation)
+    isConnectorActivationComplete(activation) &&
+    Object.keys(rootErrors).length === 0
   );
 }
 
@@ -180,7 +202,8 @@ function formatTerminal(
   indexStatus: IndexStatus,
   activation: ActivationStatus,
   contentTypeBoost: ContentTypeBoostStatus,
-  memory: MemoryStatus
+  memory: MemoryStatus,
+  rootErrors: Record<string, CollectionRootError> = {}
 ): string {
   const lines: string[] = [];
 
@@ -203,6 +226,11 @@ function formatTerminal(
         `  ${c.name}: ${c.activeDocuments} docs, ${c.totalChunks} chunks` +
           (c.embeddedChunks > 0 ? `, ${c.embeddedChunks} embedded` : "")
       );
+      const rootError = rootErrors[c.name];
+      if (rootError) {
+        lines.push(`    Root unavailable: ${c.path}`);
+        lines.push(`      [${rootError.code}] ${rootError.message}`);
+      }
       const workspace = formatLinkWorkspace(c);
       if (workspace) lines.push(`    Link workspace: ${workspace}`);
     }
@@ -240,7 +268,7 @@ function formatTerminal(
   lines.push(`Ranking fingerprint: ${contentTypeBoost.rulesFingerprint}`);
 
   lines.push(
-    `Health: ${isStatusHealthy(indexStatus, activation) ? "OK" : "DEGRADED"}`
+    `Health: ${isStatusHealthy(indexStatus, activation, rootErrors) ? "OK" : "DEGRADED"}`
   );
   lines.push("");
   const activationState = activation.healthy
@@ -290,7 +318,8 @@ function formatMarkdown(
   indexStatus: IndexStatus,
   activation: ActivationStatus,
   contentTypeBoost: ContentTypeBoostStatus,
-  memory: MemoryStatus
+  memory: MemoryStatus,
+  rootErrors: Record<string, CollectionRootError> = {}
 ): string {
   const lines: string[] = [];
 
@@ -299,7 +328,7 @@ function formatMarkdown(
   lines.push(`- **Config**: ${indexStatus.configPath}`);
   lines.push(`- **Database**: ${indexStatus.dbPath}`);
   lines.push(
-    `- **Health**: ${isStatusHealthy(indexStatus, activation) ? "✓ OK" : "⚠ DEGRADED"}`
+    `- **Health**: ${isStatusHealthy(indexStatus, activation, rootErrors) ? "✓ OK" : "⚠ DEGRADED"}`
   );
   lines.push("");
 
@@ -314,6 +343,15 @@ function formatMarkdown(
       );
     }
     lines.push("");
+    for (const c of indexStatus.collections) {
+      const rootError = rootErrors[c.name];
+      if (rootError) {
+        lines.push(
+          `- **Root unavailable**: ${c.name} (${c.path}) [${rootError.code}] ${rootError.message}`
+        );
+      }
+    }
+    if (Object.keys(rootErrors).length > 0) lines.push("");
   }
 
   lines.push("## Summary");
@@ -390,6 +428,8 @@ export async function status(
     return { success: false, error: configResult.error.message };
   }
   const config = configResult.value;
+  // Read-time root check, overlapping the index reads below; it never rejects.
+  const rootErrors = checkCollectionRoots(config.collections);
 
   // Open database
   const store = new SqliteAdapter();
@@ -446,6 +486,11 @@ export async function status(
         ...(await checkResidentRuntimes()),
       ],
       budgetStops: await collectBudgetStops(store),
+      staleCollections: await collectStaleCollections(
+        store,
+        config.collections.map(({ name }) => name)
+      ),
+      rootErrors: await rootErrors,
     };
   } finally {
     await store.close();
@@ -482,6 +527,9 @@ export function formatStatus(
           documentCount: c.activeDocuments,
           chunkCount: c.totalChunks,
           embeddedCount: c.embeddedChunks,
+          ...(result.rootErrors?.[c.name]
+            ? { rootError: result.rootErrors[c.name] }
+            : {}),
         })),
         totalDocuments: s.activeDocuments,
         totalChunks: s.totalChunks,
@@ -491,7 +539,7 @@ export function formatStatus(
         typedMetadata: s.typedMetadata,
         chunking: s.chunking,
         lastUpdated: s.lastUpdatedAt,
-        healthy: isStatusHealthy(s, result.activation),
+        healthy: isStatusHealthy(s, result.activation, result.rootErrors),
         contentTypeBoost: result.contentTypeBoost,
         activation: result.activation,
         memory: result.memory,
@@ -501,19 +549,37 @@ export function formatStatus(
         ...(result.runtimeIssues?.length
           ? { runtimeIssues: result.runtimeIssues }
           : {}),
+        ...(result.staleCollections?.length
+          ? { staleCollections: result.staleCollections }
+          : {}),
       },
       null,
       2
     );
   }
 
+  const staleLines = (result.staleCollections ?? []).map(
+    (c) =>
+      `${c.name}: ${c.documents} ${c.documents === 1 ? "document" : "documents"}`
+  );
   if (options.md) {
-    return formatMarkdown(
-      result.status,
-      result.activation,
-      result.contentTypeBoost,
-      result.memory
-    );
+    return [
+      formatMarkdown(
+        result.status,
+        result.activation,
+        result.contentTypeBoost,
+        result.memory,
+        result.rootErrors
+      ),
+      ...(staleLines.length
+        ? [
+            "",
+            `## Collections ${STALE_COLLECTIONS_HINT}`,
+            "",
+            ...staleLines.map((line) => `- ${line}`),
+          ]
+        : []),
+    ].join("\n");
   }
 
   const issueLines = result.backgroundIssues.map(
@@ -529,8 +595,16 @@ export function formatStatus(
       result.status,
       result.activation,
       result.contentTypeBoost,
-      result.memory
+      result.memory,
+      result.rootErrors
     ),
+    ...(staleLines.length
+      ? [
+          "",
+          `Collections ${STALE_COLLECTIONS_HINT}:`,
+          ...staleLines.map((line) => `  ${line}`),
+        ]
+      : []),
     ...(stopLines.length
       ? [
           "",

package/src/cli/program.ts

@@ -3651,9 +3651,14 @@ function wireManagementCommands(program: Command): void {
 
   // cleanup - Clean stale data
   addWriteLeaseFlags(
-    program.command("cleanup").description("Clean orphaned data from index")
+    program
+      .command("cleanup")
+      .description("Clean orphaned data from index")
+      .option("--json", "JSON output")
   ).action(async (cmdOpts: Record<string, unknown>) => {
-    const { cleanup, formatCleanup } = await import("./commands/cleanup");
+    const { cleanup, formatCleanup, formatDroppingCollections } =
+      await import("./commands/cleanup");
+    const json = Boolean(cmdOpts.json) || getGlobals().json;
     const lease = parseWriteLeaseFlags(cmdOpts);
     const result = await withCliWriteLease(
       {
@@ -3665,6 +3670,13 @@ function wireManagementCommands(program: Command): void {
         cleanup({
           configPath: getGlobals().config,
           indexName: getGlobals().index,
+          // Name what is about to be deleted before deleting it.
+          onDropping: (collections) => {
+            const plan = json
+              ? JSON.stringify({ deleting: collections })
+              : formatDroppingCollections(collections);
+            process.stderr.write(`${plan}\n`);
+          },
         })
     );
     throwIfWriteLeaseBusy(result, false);
@@ -3672,7 +3684,11 @@ function wireManagementCommands(program: Command): void {
     if (!result.success) {
       throw new CliError("RUNTIME", result.error ?? "Cleanup failed");
     }
-    process.stdout.write(`${formatCleanup(result)}\n`);
+    process.stdout.write(
+      json
+        ? `${JSON.stringify({ droppedCollections: result.droppedCollections, ...result.stats }, null, 2)}\n`
+        : `${formatCleanup(result)}\n`
+    );
   });
 
   // reset - Reset GNO to fresh state

package/src/core/activation-probe-plan.ts

@@ -281,7 +281,6 @@ export async function findEphemeralActivationProbeMatch(
     const search = await store.searchFts(candidate.term, {
       collection: plan.collection,
       limit: PROBE_RESULT_LIMIT,
-      snippet: false,
     });
     if (!search.ok) {
       return err(search.error.code, search.error.message, search.error.cause);