@gmickel/gno 2.7.1 → 2.8.0

package/src/cli/commands/links.ts

@@ -5,8 +5,6 @@
  * @module src/cli/commands/links
  */
 
-import { basename } from "node:path";
-
 import type {
   DocEdgeRow,
   DocLinkRow,
@@ -14,7 +12,6 @@ import type {
   StorePort,
 } from "../../store/types";
 
-import { normalizeWikiName } from "../../core/links";
 import { resolveDocRef } from "../../core/ref-parser";
 import { initStore } from "./shared";
 
@@ -51,6 +48,8 @@ export interface LinkWithResolution {
   resolved: boolean;
   resolvedDocid?: string;
   resolvedUri?: string;
+  /** Collection of the resolved target (may differ from the source's). */
+  resolvedCollection?: string;
 }
 
 export interface SemanticLinkItem {
@@ -155,6 +154,8 @@ export interface BacklinkItem {
   sourceDocid: string;
   sourceUri: string;
   sourceTitle?: string;
+  /** Collection of the linking document. */
+  sourceCollection?: string;
   linkText?: string;
   startLine: number;
   startCol: number;
@@ -233,96 +234,13 @@ export type SimilarResult =
   | { success: true; data: SimilarResponse }
   | { success: false; error: string; isValidation?: boolean };
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Helper: Build resolution indexes (cached per collection)
-// ─────────────────────────────────────────────────────────────────────────────
-
-interface ResolutionIndexes {
-  // Map: normalized wiki name -> DocumentRow
-  wikiIndex: Map<string, DocumentRow>;
-  // Map: relPath -> DocumentRow
-  pathIndex: Map<string, DocumentRow>;
-}
-
-/** Normalize markdown link path for matching (strip ./, collapse ..) */
-function normalizeMarkdownPath(path: string): string {
-  // Strip leading ./
-  let normalized = path.replace(/^\.\//, "");
-  // Collapse simple parent refs (a/b/../c -> a/c)
-  while (normalized.includes("/../")) {
-    normalized = normalized.replace(/[^/]+\/\.\.\//, "");
-  }
-  return normalized;
-}
-
-async function buildResolutionIndexes(
-  store: StorePort,
-  collection: string,
-  cache: Map<string, ResolutionIndexes>
-): Promise<ResolutionIndexes> {
-  const cached = cache.get(collection);
-  if (cached) {
-    return cached;
-  }
-
-  const indexes: ResolutionIndexes = {
-    wikiIndex: new Map(),
-    pathIndex: new Map(),
-  };
-
-  const docsResult = await store.listDocuments(collection);
-  if (!docsResult.ok) {
-    // Collection may not exist or store error - return empty indexes
-    // Links to this collection will show as unresolved
-    cache.set(collection, indexes);
-    return indexes;
-  }
-
-  for (const d of docsResult.value) {
-    if (!d.active) continue;
-
-    // Index by relPath for markdown links (exact match)
-    indexes.pathIndex.set(d.relPath, d);
-
-    // Also index by normalized path (without ./) for common variants
-    const normalizedPath = normalizeMarkdownPath(d.relPath);
-    if (
-      normalizedPath !== d.relPath &&
-      !indexes.pathIndex.has(normalizedPath)
-    ) {
-      indexes.pathIndex.set(normalizedPath, d);
-    }
-
-    // Index by normalized title for wiki links
-    if (d.title) {
-      const wikiKey = normalizeWikiName(d.title);
-      indexes.wikiIndex.set(wikiKey, d);
-    }
-
-    // Also index by filename stem as fallback for wiki links
-    const stem = basename(d.relPath).replace(/\.[^.]+$/, "");
-    if (stem) {
-      const stemKey = normalizeWikiName(stem);
-      // Don't overwrite title match
-      if (!indexes.wikiIndex.has(stemKey)) {
-        indexes.wikiIndex.set(stemKey, d);
-      }
-    }
-  }
-
-  cache.set(collection, indexes);
-  return indexes;
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Helper: Map DocLinkRow to output format (avoids null leakage)
 // ─────────────────────────────────────────────────────────────────────────────
 
 function mapLinkToOutput(
   link: DocLinkRow,
-  resolved: boolean,
-  resolvedDocid?: string,
-  resolvedUri?: string
+  resolved: { docid: string; uri: string; collection?: string } | null
 ): LinkWithResolution {
   return {
     targetRef: link.targetRef,
@@ -336,9 +254,12 @@ function mapLinkToOutput(
     startCol: link.startCol,
     endLine: link.endLine,
     endCol: link.endCol,
-    resolved,
-    ...(resolvedDocid && { resolvedDocid }),
-    ...(resolvedUri && { resolvedUri }),
+    resolved: resolved !== null,
+    ...(resolved && {
+      resolvedDocid: resolved.docid,
+      resolvedUri: resolved.uri,
+      ...(resolved.collection && { resolvedCollection: resolved.collection }),
+    }),
   };
 }
 
@@ -443,48 +364,29 @@ export async function linksList(
       return a.startCol - b.startCol;
     });
 
-    // Build resolution indexes (cached per collection)
-    const indexCache = new Map<string, ResolutionIndexes>();
-    const linksWithResolution: LinkWithResolution[] = [];
-
-    for (const link of links) {
-      let resolvedDoc: DocumentRow | undefined;
-
-      // Determine target collection (explicit or same as source)
-      const targetCollection = link.targetCollection ?? doc.collection;
-
-      // Get or build index for target collection
-      const indexes = await buildResolutionIndexes(
-        store,
-        targetCollection,
-        indexCache
-      );
-
-      // Safe fallback for targetRefNorm
-      const targetNorm = link.targetRefNorm || link.targetRef;
-
-      if (link.linkType === "wiki") {
-        // Wiki links: match by normalized title or filename
-        const wikiKey = normalizeWikiName(targetNorm);
-        resolvedDoc = indexes.wikiIndex.get(wikiKey);
-      } else {
-        // Markdown links: match by relPath (try exact, then normalized)
-        resolvedDoc = indexes.pathIndex.get(targetNorm);
-        if (!resolvedDoc) {
-          const normalizedTarget = normalizeMarkdownPath(targetNorm);
-          resolvedDoc = indexes.pathIndex.get(normalizedTarget);
-        }
-      }
-
-      linksWithResolution.push(
-        mapLinkToOutput(
-          link,
-          !!resolvedDoc,
-          resolvedDoc?.docid,
-          resolvedDoc?.uri
-        )
-      );
+    // Resolve with the shared link resolver (workspace-aware for plain wiki
+    // links whose source sits in a link workspace).
+    const resolvedResult = await store.resolveLinks(
+      links.map((link) => ({
+        targetRefNorm: link.targetRefNorm || link.targetRef,
+        targetCollection: link.targetCollection ?? doc.collection,
+        linkType: link.linkType,
+        source: {
+          collection: doc.collection,
+          relPath: doc.relPath,
+          explicit: Boolean(link.targetCollection),
+        },
+      }))
+    );
+    if (!resolvedResult.ok) {
+      return { success: false, error: resolvedResult.error.message };
     }
+    const linksWithResolution: LinkWithResolution[] = links.map(
+      (link, index) => {
+        const resolved = resolvedResult.value[index] ?? null;
+        return mapLinkToOutput(link, resolved);
+      }
+    );
 
     const resolvedCount = linksWithResolution.filter((l) => l.resolved).length;
 
@@ -606,6 +508,7 @@ export async function backlinks(
       sourceDocid: bl.sourceDocid,
       sourceUri: bl.sourceDocUri,
       ...(bl.sourceDocTitle && { sourceTitle: bl.sourceDocTitle }),
+      ...(bl.sourceCollection && { sourceCollection: bl.sourceCollection }),
       ...(bl.linkText && { linkText: bl.linkText }),
       startLine: bl.startLine,
       startCol: bl.startCol,

package/src/cli/commands/shared.ts

@@ -178,6 +178,13 @@ export function formatSyncResultLines(
       `Rechunked ${syncResult.rechunkedMirrors} cached mirrors. Run gno embed if embedding was skipped.`
     );
   }
+  if (syncResult.graphRebuild) {
+    lines.push(
+      syncResult.graphRebuild === "resolver-upgrade"
+        ? "Link graph rebuilt: link resolution was upgraded."
+        : "Link graph rebuilt: collection settings or link workspace membership changed."
+    );
+  }
 
   for (const c of syncResult.collections) {
     lines.push(`${c.collection}:`);

package/src/cli/commands/status.ts

@@ -21,6 +21,7 @@ import {
 import { isConnectorActivationComplete } from "../../core/activation-connector-health";
 import { buildActivationStatus } from "../../core/activation-status";
 import { formatChunkingStatus } from "../../core/chunking-status";
+import { formatLinkWorkspace } from "../../core/link-workspace";
 import {
   buildMemoryStatus,
   formatMemoryStatusLines,
@@ -140,6 +141,8 @@ function formatTerminal(
         `  ${c.name}: ${c.activeDocuments} docs, ${c.totalChunks} chunks` +
           (c.embeddedChunks > 0 ? `, ${c.embeddedChunks} embedded` : "")
       );
+      const workspace = formatLinkWorkspace(c);
+      if (workspace) lines.push(`    Link workspace: ${workspace}`);
     }
   }
 
@@ -395,6 +398,8 @@ export function formatStatus(
         collections: s.collections.map((c) => ({
           name: c.name,
           path: c.path,
+          ...(c.workspaceRoot ? { workspaceRoot: c.workspaceRoot } : {}),
+          workspaceSource: c.workspaceSource ?? "none",
           documentCount: c.activeDocuments,
           chunkCount: c.totalChunks,
           embeddedCount: c.embeddedChunks,

package/src/cli/program.ts

@@ -1694,7 +1694,10 @@ function wireOnboardingCommands(program: Command): void {
       collectRepeatableValue,
       []
     )
-    .option("--max-findings <count>", "maximum returned findings", Number)
+    .option(
+      "--max-findings <count>",
+      "maximum returned findings (1-100000, or all)"
+    )
     .option("--max-age-days <days>", "explicit age review signal", Number)
     .option(
       "--orphan-root <uri>",
@@ -1736,7 +1739,7 @@ function wireOnboardingCommands(program: Command): void {
             collections: cmdOpts.collection as string[],
             paths: cmdOpts.path as string[],
             tags: cmdOpts.tag as string[],
-            maxFindings: cmdOpts.maxFindings as number | undefined,
+            maxFindings: cmdOpts.maxFindings as string | undefined,
             maxAgeDays: cmdOpts.maxAgeDays as number | undefined,
             orphanRoots: cmdOpts.orphanRoot as string[],
             orphanIgnorePrefixes: cmdOpts.orphanIgnorePrefix as string[],
@@ -4749,6 +4752,12 @@ function wireKnowledgeDeltaCommands(program: Command): void {
   program
     .command("impact <doc>")
     .description("Find bounded inbound knowledge dependencies")
+    .option(
+      "-c, --collection <name>",
+      "only traverse these collections (repeatable; default all)",
+      collectRepeatableValue,
+      []
+    )
     .option("--max-depth <n>", "maximum dependency depth", "3")
     .option("--max-nodes <n>", "maximum returned nodes", "100")
     .option("--max-edges <n>", "maximum traversed evidence edges", "250")
@@ -4764,6 +4773,7 @@ function wireKnowledgeDeltaCommands(program: Command): void {
       const result = await impact(
         doc,
         {
+          collections: cmdOpts.collection as string[],
           maxDepth: parsePositiveInt("max-depth", cmdOpts.maxDepth),
           maxNodes: parsePositiveInt("max-nodes", cmdOpts.maxNodes),
           maxEdges: parsePositiveInt("max-edges", cmdOpts.maxEdges),

package/src/config/loader.ts

@@ -7,6 +7,10 @@
 
 import type { ZodError } from "zod";
 
+import {
+  validateWorkspaceRootSetting,
+  workspaceRootSettingMessage,
+} from "../core/link-workspace";
 import {
   normalizeConfigContentTypes,
   type ConfigWarning,
@@ -132,6 +136,18 @@ export async function loadConfigFromPath(
     };
   }
 
+  const workspaceIssues = validateCollectionWorkspaceRoots(result.data);
+  if (workspaceIssues.length > 0) {
+    return {
+      ok: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message: `Config validation failed: ${workspaceIssues.map((issue) => issue.message).join("; ")}`,
+        issues: workspaceIssues,
+      },
+    };
+  }
+
   const normalized = normalizeConfigContentTypes(result.data);
   return {
     ok: true,
@@ -140,6 +156,33 @@ export async function loadConfigFromPath(
   };
 }
 
+/**
+ * Validate explicit `workspaceRoot` settings against the filesystem: each must
+ * be absolute, exist, and contain its collection root. Messages name the
+ * collection so the error is actionable.
+ */
+export function validateCollectionWorkspaceRoots(
+  config: Config
+): ZodError["issues"] {
+  const issues: ZodError["issues"] = [];
+  for (const [index, collection] of config.collections.entries()) {
+    if (typeof collection.workspaceRoot !== "string") continue;
+    const error = validateWorkspaceRootSetting(
+      collection.path,
+      collection.workspaceRoot
+    );
+    if (error) {
+      issues.push({
+        code: "custom",
+        message: workspaceRootSettingMessage(collection.name, error),
+        path: ["collections", index, "workspaceRoot"],
+        input: collection.workspaceRoot,
+      });
+    }
+  }
+  return issues;
+}
+
 /**
  * Load config, returning null if not found (convenience wrapper).
  * Throws on parse/validation errors.

package/src/config/types.ts

@@ -166,6 +166,14 @@ export const CollectionSchema = z.object({
    */
   sourceAvailability: SourceAvailabilitySchema.optional(),
 
+  /**
+   * Link workspace for plain wiki links. Omitted: auto-detect the nearest
+   * `.obsidian/` ancestor-or-self. An absolute path joins the collection to
+   * that workspace root (it must contain the collection root); `false` keeps
+   * the collection's links collection-scoped.
+   */
+  workspaceRoot: z.union([z.string().min(1), z.literal(false)]).optional(),
+
   /**
    * Declares the collection as a GNO-managed memory substrate: `remember`
    * writes fact files here and refuses every collection without the flag.

package/src/core/audit-contract.ts

@@ -11,8 +11,11 @@ export const AUDIT_RULE_SET_VERSION = "1.0" as const;
 
 /** Default returned finding cap; totals remain exact when truncated. */
 export const AUDIT_DEFAULT_MAX_FINDINGS = 100;
-/** Hard upper bound for `--max-findings` / MCP maxFindings. */
-export const AUDIT_MAX_FINDINGS_LIMIT = 1000;
+/** Hard numeric upper bound for `--max-findings` / MCP maxFindings. */
+export const AUDIT_MAX_FINDINGS_LIMIT = 100_000;
+/** Returns every finding of the bounded audit snapshot. */
+export const AUDIT_MAX_FINDINGS_ALL = "all" as const;
+export type AuditMaxFindings = number | typeof AUDIT_MAX_FINDINGS_ALL;
 export const AUDIT_MAX_EVIDENCE_PER_FINDING = 8;
 export const AUDIT_MAX_GUIDANCE_PER_FINDING = 4;
 export const AUDIT_MAX_EVIDENCE_DETAIL_CHARS = 512;
@@ -201,7 +204,14 @@ export interface AuditCounts {
 
 export interface AuditTruncation {
   findingsTruncated: boolean;
-  maxFindings: number;
+  maxFindings: AuditMaxFindings;
+  /**
+   * The bounded audit snapshot (documents or links) was cut; finding totals
+   * cover the snapshot only and are not complete-index totals.
+   */
+  snapshotTruncated: boolean;
+  /** Evidence items, candidate lists or evidence detail text were clipped. */
+  evidenceTruncated: boolean;
 }
 
 export interface AuditTiming {
@@ -255,6 +265,8 @@ export interface AuditRuleContribution {
   findings?: AuditFindingDraft[];
   /** Exact findings before any evaluator-side payload cap. */
   findingCount?: number;
+  /** Evaluator clipped evidence (for example a long tied-candidate list). */
+  evidenceTruncated?: boolean;
   examinedCount?: number;
   durationMs?: number;
   skipReason?: string | null;
@@ -283,7 +295,7 @@ export interface AuditRunInput {
   capabilities: AuditCapabilitySnapshot;
   captureFingerprints: AuditFingerprintCapture;
   rules: readonly AuditRuleEvaluator[];
-  maxFindings?: number;
+  maxFindings?: AuditMaxFindings;
   maxAttempts?: number;
   gnoVersion?: string;
   clock?: () => Date;

package/src/core/audit-freshness.ts

@@ -33,6 +33,8 @@ export interface AuditFreshnessOptions {
   now: Date;
   agePolicy?: AuditAgePolicy;
   truncated?: boolean;
+  /** Effective per-rule cap; defaults to FRESHNESS_AUDIT_MAX_FINDINGS_PER_RULE. */
+  maxFindingsPerRule?: number;
 }
 
 const finding = (input: {
@@ -68,6 +70,7 @@ const rule = (input: {
   skipped?: boolean;
   message: string;
   reason?: string;
+  maxFindingsPerRule?: number;
 }): AuditRuleContribution => ({
   ruleId: input.ruleId,
   category: "freshness",
@@ -83,7 +86,10 @@ const rule = (input: {
   message: input.message,
   findings: [...input.findings]
     .sort(compareAuditFindingDrafts)
-    .slice(0, FRESHNESS_AUDIT_MAX_FINDINGS_PER_RULE),
+    .slice(
+      0,
+      input.maxFindingsPerRule ?? FRESHNESS_AUDIT_MAX_FINDINGS_PER_RULE
+    ),
   findingCount: input.findings.length,
   examinedCount: input.examinedCount,
   skipReason: input.reason ?? null,
@@ -186,6 +192,7 @@ export const evaluateFreshnessAudit = (
       : undefined;
   return [
     rule({
+      maxFindingsPerRule: options.maxFindingsPerRule,
       ruleId: "freshness.source-readable",
       findings: unavailable,
       examinedCount: documents.length,
@@ -197,6 +204,7 @@ export const evaluateFreshnessAudit = (
       reason,
     }),
     rule({
+      maxFindingsPerRule: options.maxFindingsPerRule,
       ruleId: "freshness.source-index-drift",
       findings: drift,
       examinedCount: byteComparableCount,
@@ -207,6 +215,7 @@ export const evaluateFreshnessAudit = (
       reason,
     }),
     rule({
+      maxFindingsPerRule: options.maxFindingsPerRule,
       ruleId: "freshness.index-revision",
       findings: staleRevision,
       examinedCount: documents.length,
@@ -217,6 +226,7 @@ export const evaluateFreshnessAudit = (
       reason,
     }),
     rule({
+      maxFindingsPerRule: options.maxFindingsPerRule,
       ruleId: "freshness.configured-age-signal",
       findings: ageSignals,
       examinedCount: documents.length,