@gmickel/gno 2.7.0 → 2.8.0

package/src/core/context-evidence.ts

@@ -40,6 +40,7 @@ import {
 import { planContextEvidence } from "./context-compiler";
 import { projectContextEvidenceMetadata } from "./context-evidence-metadata";
 import { createEgressLineage, resolveEgressLineage } from "./egress-provenance";
+import { linkResolutionFingerprintInput } from "./link-workspace";
 import { projectRecordEvidenceMetadata } from "./record-metadata";
 import {
   extractInclusiveLines,
@@ -205,6 +206,13 @@ const canonicalIndexSnapshot = (
     ),
 });
 
+const linkResolutionEntry = (
+  rows: Parameters<typeof linkResolutionFingerprintInput>[0]
+): { linkResolution?: ReturnType<typeof linkResolutionFingerprintInput> } => {
+  const linkResolution = linkResolutionFingerprintInput(rows);
+  return linkResolution ? { linkResolution } : {};
+};
+
 /** Capture one strict, content-free index/context snapshot before or after work. */
 export const captureContextEvidenceSnapshot = async (
   store: ContextEvidenceStore,
@@ -284,6 +292,9 @@ export const captureContextEvidenceSnapshot = async (
     indexFingerprint: hashJson({
       snapshots: indexSnapshots,
       egressLineage,
+      // Link workspace membership decides graph neighbours; a membership or
+      // resolver change is index drift. Absent without any workspace.
+      ...linkResolutionEntry(collectionRows),
     }),
   };
 };

package/src/core/graph-edge-confidence.ts

@@ -17,8 +17,30 @@ export const GRAPH_EDGE_CONFIDENCE_RANK: Record<GraphEdgeConfidence, number> = {
 export function classifyResolvedGraphEdge(
   linkType: "wiki" | "markdown",
   matchRank: number | null,
-  matchCount: number | null
+  matchCount: number | null,
+  /** Workspace resolution reason; semantic, independent of legacy ranks. */
+  reason?: string
 ): { confidence: GraphEdgeConfidence; audit: GraphEdgeAudit } {
+  if (linkType === "wiki" && reason !== undefined && reason !== "title") {
+    switch (reason) {
+      case "workspace-path":
+      case "collection-path":
+        return {
+          confidence: "explicit",
+          audit: { resolution: "exact-path", matchCount: 1 },
+        };
+      case "exact-name":
+        return {
+          confidence: "explicit",
+          audit: { resolution: "exact-name", matchCount: 1 },
+        };
+      default:
+        return {
+          confidence: "inferred",
+          audit: { resolution: "tie-break", matchCount: 1 },
+        };
+    }
+  }
   if (linkType === "markdown") {
     return {
       confidence: "explicit",

package/src/core/host-paths.ts

@@ -6,26 +6,45 @@
  * peek receipts). A remote caller identifies documents by `uri` and
  * collection-relative `relPath` instead, so every `absPath` key is removed
  * before a payload leaves a remote-reachable surface.
+ *
+ * Status, collection, and connector payloads also name owner configuration
+ * locations: `configPath`, `dbPath`, and `path` (collection roots, suggested
+ * folders, model cache and model files, connector targets). A remote caller
+ * identifies a collection by `name`, so those keys are removed from those
+ * payloads too.
  */
 
-const HOST_PATH_FIELD = "absPath";
+/** Document host path key of result payloads. */
+export const HOST_PATH_FIELDS: ReadonlySet<string> = new Set(["absPath"]);
+
+/** Owner configuration path keys of status, collection, and connector payloads. */
+export const OWNER_CONFIG_PATH_FIELDS: ReadonlySet<string> = new Set([
+  "configPath",
+  "dbPath",
+  "path",
+  "workspaceRoot",
+]);
 
 const isPlainObject = (value: object): boolean => {
   const proto = Object.getPrototypeOf(value) as object | null;
   return proto === Object.prototype || proto === null;
 };
 
-/** Deep copy of a JSON-shaped value with every `absPath` key removed. */
-export function withoutHostPaths<T>(value: T): T {
+/** Deep copy of a JSON-shaped value with every key in `fields` removed. */
+export function withoutFields<T>(value: T, fields: ReadonlySet<string>): T {
   if (Array.isArray(value)) {
-    return value.map((item: unknown) => withoutHostPaths(item)) as T;
+    return value.map((item: unknown) => withoutFields(item, fields)) as T;
   }
   if (value === null || typeof value !== "object" || !isPlainObject(value)) {
     return value;
   }
   const copy: Record<string, unknown> = {};
   for (const [key, entry] of Object.entries(value)) {
-    if (key !== HOST_PATH_FIELD) copy[key] = withoutHostPaths(entry);
+    if (!fields.has(key)) copy[key] = withoutFields(entry, fields);
   }
   return copy as T;
 }
+
+/** Deep copy of a JSON-shaped value with every `absPath` key removed. */
+export const withoutHostPaths = <T>(value: T): T =>
+  withoutFields(value, HOST_PATH_FIELDS);

package/src/core/knowledge-impact.ts

@@ -41,6 +41,12 @@ export interface KnowledgeImpactResult {
 }
 
 export interface KnowledgeImpactInput {
+  /**
+   * Collection scope: only documents in these collections are traversed or
+   * returned, and a document outside them is never used as a bridge.
+   * Omitted or empty means every indexed collection.
+   */
+  collections?: string[];
   maxDepth?: number;
   maxNodes?: number;
   maxEdges?: number;
@@ -118,8 +124,30 @@ export async function analyzeKnowledgeImpact(
       isValidation: true,
     };
   }
+  const scope = [...new Set(input.collections ?? [])].sort();
+  if (scope.length > 0) {
+    const known = await store.getCollections();
+    if (!known.ok) return { success: false, error: known.error.message };
+    const names = new Set(known.value.map((row) => row.name));
+    const missing = scope.find((name) => !names.has(name));
+    if (missing) {
+      return {
+        success: false,
+        error: `Collection not found: ${missing}`,
+        isValidation: true,
+      };
+    }
+    if (!scope.includes(resolved.doc.collection)) {
+      return {
+        success: false,
+        error: `Document is outside the requested collections: ${ref}`,
+        isValidation: true,
+      };
+    }
+  }
   const traversal = await store.queryGraphTraversal(resolved.doc.id, {
     direction: "in",
+    ...(scope.length > 0 ? { collections: scope } : {}),
     maxDepth: values.maxDepth,
     maxNodes: values.maxNodes,
     frontierLimit: values.frontierLimit,

package/src/core/link-workspace.ts

@@ -0,0 +1,324 @@
+/**
+ * Link workspaces: collections whose roots share one workspace root resolve
+ * plain wiki links across each other (Obsidian vault semantics).
+ *
+ * Membership is derived from the filesystem, never stored in content: the
+ * nearest ancestor-or-self directory containing `.obsidian/`, or an explicit
+ * per-collection `workspaceRoot` (absolute path, or `false` to opt out).
+ * Ownership is finally decided per document: a nested vault (`.obsidian/`
+ * below the collection root) forms its own workspace.
+ *
+ * @module src/core/link-workspace
+ */
+
+// node:fs has no Bun equivalent for synchronous realpath/stat of directories.
+import { realpathSync, statSync } from "node:fs";
+// node:path provides platform-correct path algebra; Bun has no path utilities.
+import { dirname, isAbsolute, relative, sep } from "node:path";
+
+/** Bump when resolution semantics change; enters projection fingerprints. */
+export const LINK_RESOLVER_VERSION = 2;
+
+export const WORKSPACE_MARKER_DIR = ".obsidian";
+
+export type LinkWorkspaceSource =
+  /** No workspace root: collection-scoped resolution (today's behaviour). */
+  | "none"
+  /** Nearest `.obsidian/` ancestor-or-self of the collection root. */
+  | "detected"
+  /** Explicit absolute `workspaceRoot`. */
+  | "configured"
+  /** Explicit `workspaceRoot: false` opt-out. */
+  | "disabled"
+  /** Root or ancestors could not be inspected; fails closed to collection scope. */
+  | "unavailable";
+
+export interface CollectionWorkspaceInfo {
+  /** Canonical (real) collection root, or null when it cannot be resolved. */
+  realPath: string | null;
+  /** Canonical workspace root, or null for collection-scoped resolution. */
+  root: string | null;
+  source: LinkWorkspaceSource;
+}
+
+/** Stored membership of one collection, as read back from the index. */
+export interface CollectionWorkspaceMembership extends CollectionWorkspaceInfo {
+  collection: string;
+  /** Collection-relative POSIX prefixes that hold their own `.obsidian/`. */
+  nested: string[];
+}
+
+type DirProbe = "present" | "absent" | "error";
+
+const probeMarker = (directory: string): DirProbe => {
+  try {
+    return statSync(`${directory}${sep}${WORKSPACE_MARKER_DIR}`).isDirectory()
+      ? "present"
+      : "absent";
+  } catch (cause) {
+    const code = (cause as NodeJS.ErrnoException | undefined)?.code;
+    return code === "ENOENT" || code === "ENOTDIR" ? "absent" : "error";
+  }
+};
+
+const canonical = (path: string): string | null => {
+  try {
+    return realpathSync(path).normalize("NFC");
+  } catch {
+    return null;
+  }
+};
+
+/** Join a POSIX relative path onto a native absolute root. */
+const nativeJoin = (root: string, posixPath: string): string =>
+  `${root}${sep}${posixPath.split("/").join(sep)}`;
+
+/** True when `child` equals `parent` or sits inside it (component-wise). */
+export const pathContains = (parent: string, child: string): boolean => {
+  const rel = relative(parent, child);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+};
+
+/** POSIX path of `child` relative to `parent` ('' when equal). */
+export const posixRelative = (parent: string, child: string): string =>
+  relative(parent, child).split(sep).join("/").normalize("NFC");
+
+export type WorkspaceRootSettingError =
+  | "not_absolute"
+  | "not_found"
+  | "not_containing";
+
+/** Validate an explicit `workspaceRoot` against the collection root. */
+export const validateWorkspaceRootSetting = (
+  collectionPath: string,
+  workspaceRoot: string
+): WorkspaceRootSettingError | null => {
+  if (!isAbsolute(workspaceRoot)) return "not_absolute";
+  const root = canonical(workspaceRoot);
+  if (root === null) return "not_found";
+  try {
+    if (!statSync(root).isDirectory()) return "not_found";
+  } catch {
+    return "not_found";
+  }
+  const collectionRoot = canonical(collectionPath) ?? collectionPath;
+  return pathContains(root, collectionRoot) ? null : "not_containing";
+};
+
+export const workspaceRootSettingMessage = (
+  collection: string,
+  error: WorkspaceRootSettingError
+): string => {
+  switch (error) {
+    case "not_absolute":
+      return `Collection "${collection}": workspaceRoot must be an absolute path`;
+    case "not_found":
+      return `Collection "${collection}": workspaceRoot does not exist or is not a directory`;
+    case "not_containing":
+      return `Collection "${collection}": workspaceRoot must contain the collection root`;
+  }
+};
+
+/**
+ * Resolve one collection's workspace from its root. Real paths are used
+ * throughout; an unreadable root or ancestor never joins a broader workspace.
+ */
+export const detectCollectionWorkspace = (collection: {
+  path: string;
+  workspaceRoot?: string | false;
+}): CollectionWorkspaceInfo => {
+  const realPath = canonical(collection.path);
+  if (collection.workspaceRoot === false) {
+    return { realPath, root: null, source: "disabled" };
+  }
+  if (realPath === null) {
+    return { realPath: null, root: null, source: "unavailable" };
+  }
+  if (typeof collection.workspaceRoot === "string") {
+    const invalid = validateWorkspaceRootSetting(
+      collection.path,
+      collection.workspaceRoot
+    );
+    const root = invalid ? null : canonical(collection.workspaceRoot);
+    return root === null
+      ? { realPath, root: null, source: "unavailable" }
+      : { realPath, root, source: "configured" };
+  }
+  let current = realPath;
+  for (;;) {
+    const probe = probeMarker(current);
+    if (probe === "present") {
+      return { realPath, root: current, source: "detected" };
+    }
+    if (probe === "error") {
+      return { realPath, root: null, source: "unavailable" };
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return { realPath, root: null, source: "none" };
+    }
+    current = parent;
+  }
+};
+
+/**
+ * Find nested vaults inside a collection: every ancestor directory of an
+ * indexed document (below the collection root) that holds `.obsidian/`.
+ * Bounded by distinct directories, never by link count.
+ */
+export const detectNestedWorkspacePrefixes = (
+  realRoot: string,
+  relPaths: Iterable<string>
+): string[] => {
+  const directories = new Set<string>();
+  for (const relPath of relPaths) {
+    let directory = relPath.includes("/")
+      ? relPath.slice(0, relPath.lastIndexOf("/"))
+      : "";
+    while (directory && !directories.has(directory)) {
+      directories.add(directory);
+      directory = directory.includes("/")
+        ? directory.slice(0, directory.lastIndexOf("/"))
+        : "";
+    }
+  }
+  const nested: string[] = [];
+  for (const directory of directories) {
+    if (probeMarker(nativeJoin(realRoot, directory)) === "present") {
+      nested.push(directory.normalize("NFC"));
+    }
+  }
+  return nested.sort();
+};
+
+/**
+ * Fingerprint input for effective link resolution: resolver version plus the
+ * membership of every collection that belongs to (or contains) a workspace.
+ * Undefined when no collection is in a workspace, so collection-scoped
+ * indexes keep their existing fingerprints.
+ */
+export const linkResolutionFingerprintInput = (
+  rows: ReadonlyArray<{
+    name: string;
+    realPath?: string | null;
+    workspaceRoot?: string | null;
+    workspaceSource?: LinkWorkspaceSource;
+    workspaceNested?: string[];
+  }>
+):
+  | {
+      version: number;
+      workspaces: Array<{
+        collection: string;
+        realPath: string | null;
+        root: string | null;
+        source: LinkWorkspaceSource;
+        nested: string[];
+      }>;
+    }
+  | undefined => {
+  const workspaces = rows
+    .filter(
+      (row) =>
+        (row.workspaceRoot ?? null) !== null ||
+        (row.workspaceNested?.length ?? 0) > 0
+    )
+    .map((row) => ({
+      collection: row.name,
+      realPath: row.realPath ?? null,
+      root: row.workspaceRoot ?? null,
+      source: row.workspaceSource ?? "none",
+      nested: [...(row.workspaceNested ?? [])].sort(),
+    }))
+    .sort((left, right) =>
+      left.collection < right.collection
+        ? -1
+        : left.collection > right.collection
+          ? 1
+          : 0
+    );
+  return workspaces.length > 0
+    ? { version: LINK_RESOLVER_VERSION, workspaces }
+    : undefined;
+};
+
+/**
+ * One-line link workspace description for status output, or null for a
+ * collection that is not in a workspace. A redacted root prints no path.
+ */
+export const formatLinkWorkspace = (collection: {
+  workspaceRoot?: string | null;
+  workspaceSource?: string;
+}): string | null => {
+  switch (collection.workspaceSource) {
+    case "detected":
+    case "configured":
+      return collection.workspaceRoot
+        ? `${collection.workspaceRoot} (${collection.workspaceSource})`
+        : collection.workspaceSource;
+    case "disabled":
+      return "off (links stay inside this collection)";
+    case "unavailable":
+      return "unavailable (links stay inside this collection)";
+    default:
+      return null;
+  }
+};
+
+/** Workspace identity and workspace-relative path of one document. */
+export interface DocumentWorkspacePlacement {
+  /** Canonical workspace root (the workspace identity), or null. */
+  key: string | null;
+  /** Document path relative to the workspace root (POSIX, NFC). */
+  path: string;
+}
+
+/** Collection root relative to its workspace root, per membership object. */
+const workspacePrefixes = new WeakMap<CollectionWorkspaceMembership, string>();
+
+/**
+ * Place a document into its workspace: the deepest nested vault containing
+ * it, else its collection's workspace. Collection-scoped collections (none,
+ * disabled, unavailable) never place documents into a workspace, except that
+ * nested vaults still own their documents when the collection root is known
+ * and not opted out.
+ */
+export const placeDocument = (
+  membership: CollectionWorkspaceMembership | undefined,
+  relPath: string
+): DocumentWorkspacePlacement => {
+  const normalized = relPath.normalize("NFC");
+  if (
+    !membership ||
+    membership.realPath === null ||
+    membership.source === "disabled" ||
+    membership.source === "unavailable"
+  ) {
+    return { key: null, path: normalized };
+  }
+  let nestedPrefix: string | null = null;
+  for (const prefix of membership.nested) {
+    if (
+      normalized.startsWith(`${prefix}/`) &&
+      (nestedPrefix === null || prefix.length > nestedPrefix.length)
+    ) {
+      nestedPrefix = prefix;
+    }
+  }
+  if (nestedPrefix !== null) {
+    return {
+      key: nativeJoin(membership.realPath, nestedPrefix),
+      path: normalized.slice(nestedPrefix.length + 1),
+    };
+  }
+  if (membership.root === null) return { key: null, path: normalized };
+  let prefix = workspacePrefixes.get(membership);
+  if (prefix === undefined) {
+    prefix = posixRelative(membership.root, membership.realPath);
+    workspacePrefixes.set(membership, prefix);
+  }
+  return {
+    key: membership.root,
+    path: prefix ? `${prefix}/${normalized}` : normalized,
+  };
+};

package/src/core/request-receipts.ts

@@ -11,14 +11,18 @@
  */
 
 import { Database } from "bun:sqlite";
-// node:fs/promises chmod/mkdir: filesystem structure ops, no Bun equivalent
-import { chmod, mkdir } from "node:fs/promises";
+// node:fs/promises chmod/mkdir/lstat/readdir: filesystem structure ops, no Bun equivalent
+import { chmod, lstat, mkdir, readdir } from "node:fs/promises";
 // node:path has no Bun path utilities
 import { basename, dirname, join } from "node:path";
 
 import { MCP_ERRORS } from "./errors";
 import { withWriteLock } from "./file-lock";
-import { windowsPrivatePath } from "./windows-private-path";
+import {
+  isOwnerOnlyDescriptor,
+  windowsDirectoryDescriptor,
+  windowsPrivatePath,
+} from "./windows-private-path";
 import { writeLeasePath } from "./write-lease";
 
 /** Committed receipts keep their full outcome this long, then become tombstones. */
@@ -221,25 +225,75 @@ CREATE TABLE IF NOT EXISTS request_receipts (
 /** Ledger directories whose owner-only Windows DACL this process verified. */
 const privateLedgerDirs = new Set<string>();
 
+/** Inside the ledger directory: what the last authoritative check verified. */
+const LEDGER_DIR_MARKER = ".owner-only-verified";
+
+export interface PrivateDirAcl {
+  /** Authoritative check (spawns PowerShell); `create` sets the owner-only DACL first. */
+  verify: (dir: string, create: boolean) => Promise<void>;
+  /** In-process owner and DACL bytes, or null when they cannot be read. */
+  descriptor: (dir: string) => Uint8Array | null;
+}
+
+const WINDOWS_ACL: PrivateDirAcl = {
+  verify: windowsPrivatePath,
+  descriptor: windowsDirectoryDescriptor,
+};
+
+/** Directory identity plus descriptor digest; null unless owner-only. */
+async function ledgerDirStamp(
+  dir: string,
+  acl: PrivateDirAcl
+): Promise<string | null> {
+  const { dev, ino } = await lstat(dir, { bigint: true });
+  const descriptor = acl.descriptor(dir);
+  if (!descriptor || !isOwnerOnlyDescriptor(descriptor)) return null;
+  const digest = new Bun.CryptoHasher("sha256")
+    .update(descriptor)
+    .digest("hex");
+  return `${dev}:${ino}:${digest}`;
+}
+
 /**
  * Windows ignores POSIX modes: give a new ledger directory the current-user
  * DACL before SQLite creates the database or its WAL/SHM (they inherit it),
  * and refuse an existing one that grants another principal access.
+ *
+ * The PowerShell check costs a process start, so its success is recorded in a
+ * marker inside the directory. A later open skips it only when the directory
+ * is the same object and its owner and DACL are byte-identical to the verified
+ * ones and still owner-only; reading the marker at all requires access that
+ * owner-only DACL grants. Anything else re-runs the authoritative check.
+ *
+ * An existing but empty directory is secured like a new one: a first open
+ * interrupted before its DACL was set leaves exactly that, and nothing inside
+ * it could have been exposed.
  */
-async function secureLedgerDir(
+export async function securePrivateLedgerDir(
   dir: string,
-  created: string | undefined
+  created: boolean,
+  acl: PrivateDirAcl = WINDOWS_ACL
 ): Promise<void> {
-  if (process.platform !== "win32" || privateLedgerDirs.has(dir)) return;
-  await windowsPrivatePath(dir, created !== undefined);
-  privateLedgerDirs.add(dir);
+  const marker = Bun.file(join(dir, LEDGER_DIR_MARKER));
+  if (!created) {
+    const stamp = await ledgerDirStamp(dir, acl);
+    if (stamp !== null && stamp === (await marker.text().catch(() => null)))
+      return;
+  }
+  const secure = created || (await readdir(dir)).length === 0;
+  await acl.verify(dir, secure);
+  const stamp = await ledgerDirStamp(dir, acl);
+  if (stamp !== null) await Bun.write(marker, stamp);
 }
 
 async function openLedger(path: string): Promise<Database> {
   try {
     const dir = dirname(path);
     const created = await mkdir(dir, { recursive: true, mode: 0o700 });
-    await secureLedgerDir(dir, created);
+    if (process.platform === "win32" && !privateLedgerDirs.has(dir)) {
+      await securePrivateLedgerDir(dir, created !== undefined);
+      privateLedgerDirs.add(dir);
+    }
     const db = new Database(path, { create: true, strict: true });
     try {
       // POSIX: private before any journal file exists (they inherit this mode).

package/src/core/retrieval-replay-candidate.ts

@@ -303,6 +303,12 @@ export const runRetrievalReplayCandidate = async (
       retrievalScope
     );
     options.limit = scope.value.fetchLimit;
+    const scopedCollections = scope.value.collections.filter(
+      (name): name is string => name !== undefined
+    );
+    if (scopedCollections.length > 0) {
+      options.graphCollections = scopedCollections;
+    }
     const result = await runCandidateOnce(deps, source, candidate, options);
     if (!result.ok) return result;
     outputs.push(result.value);

package/src/core/retrieval-trace-request.ts

@@ -8,6 +8,7 @@ import type { RetrievalTraceTerminalStatus } from "../store/types";
 
 import { canonicalTraceJson } from "../store/retrieval-trace-codec";
 import { err, ok } from "../store/types";
+import { linkResolutionFingerprintInput } from "./link-workspace";
 import { RetrievalTraceSession } from "./retrieval-trace-session";
 
 export const retrievalTraceFailureStatus = (
@@ -45,6 +46,7 @@ export const buildRetrievalTraceFingerprints = async (input: {
 }): Promise<RetrievalTraceFingerprints> => {
   const collections = await input.store.getCollections();
   if (!collections.ok) throw new Error(collections.error.message);
+  const linkResolution = linkResolutionFingerprintInput(collections.value);
   const snapshots = [];
   for (const collection of [...collections.value].sort((left, right) =>
     left.name.localeCompare(right.name)
@@ -70,6 +72,7 @@ export const buildRetrievalTraceFingerprints = async (input: {
     index: fingerprint({
       indexName: input.indexName ?? "default",
       snapshots,
+      ...(linkResolution ? { linkResolution } : {}),
     }),
   };
 };