@wrongstack/core 0.308.5 → 0.308.7

package/dist/plugin/discovery.d.ts

@@ -0,0 +1,73 @@
+/**
+ * External plugin discovery — filesystem convention for third-party plugins.
+ *
+ * Two roots are scanned (when present):
+ *   - `~/.wrongstack/plugins/`          — user-global plugins
+ *   - `<projectRoot>/.wrongstack/plugins/` — project-local plugins
+ *
+ * Each immediate child of a root is a candidate:
+ *   - a directory named `<plugin-name>/` whose entry is resolved from
+ *     `package.json` (`main` / `exports["."]`) or falls back to
+ *     `index.js` / `index.mjs` / `index.cjs`,
+ *   - or a single entry file (`<plugin-name>.js` / `.mjs` / `.cjs`).
+ *
+ * `node_modules` and dot-entries are skipped: packages installed by
+ * `wstack plugin add --install` are loaded through their explicit
+ * `path` config entry, not through directory discovery, so they are
+ * never double-loaded. Scan order is alphabetical per root for
+ * deterministic load order; roots are scanned in the order given.
+ *
+ * Discovery is read-only and never imports plugin code — resolving an
+ * entry does not execute it. The host decides what to do with the
+ * candidates (enablement, trust pinning, import).
+ */
+import type { Dirent } from 'node:fs';
+export interface ExternalPluginCandidate {
+    /** Candidate name — the directory or file basename without extension. */
+    name: string;
+    /** Absolute path of the resolved JavaScript entry file. */
+    entryPath: string;
+    /** Discovery root the candidate was found under. */
+    root: string;
+}
+export interface SkippedPluginCandidate {
+    name: string;
+    root: string;
+    reason: string;
+}
+export interface PluginDiscoveryResult {
+    candidates: ExternalPluginCandidate[];
+    /** Candidates that were found but could not be resolved to an entry. */
+    skipped: SkippedPluginCandidate[];
+}
+/** Injectable filesystem access so discovery is unit-testable. */
+export interface DiscoveryIo {
+    readdir(root: string): Promise<Dirent[]>;
+    stat(path: string): Promise<{
+        isFile(): boolean;
+        isDirectory(): boolean;
+    }>;
+    readFile(path: string): Promise<string>;
+}
+export declare const DEFAULT_PLUGIN_DISCOVERY_IO: DiscoveryIo;
+/**
+ * Resolve the JavaScript entry file for a plugin directory: `package.json`
+ * `main`/`exports["."]` first, then `index.js`/`index.mjs`/`index.cjs`
+ * probing. Returns null when no entry can be resolved. Shared by directory
+ * discovery and explicit `config.plugins[].path` resolution. Paths are
+ * returned with forward separators on every platform so trust pin keys and
+ * import targets stay canonical.
+ */
+export declare function resolvePluginEntryPath(dir: string, io?: DiscoveryIo): Promise<string | null>;
+/**
+ * Resolve a configured target (entry file OR directory) to its entry file.
+ * Returns the input (forward-slash normalized) when it is already a file;
+ * null when it is a directory without a resolvable entry or does not exist.
+ */
+export declare function resolvePluginTarget(target: string, io?: DiscoveryIo): Promise<string | null>;
+/**
+ * Scan discovery roots for external plugin candidates. Missing roots are
+ * not an error — they simply contribute no candidates.
+ */
+export declare function discoverExternalPlugins(roots: readonly string[], io?: DiscoveryIo): Promise<PluginDiscoveryResult>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/plugin/index.d.ts

@@ -1,6 +1,8 @@
 export { DefaultPluginAPI, definePlugin, type PluginAPIInit } from './api.js';
+export { DEFAULT_PLUGIN_DISCOVERY_IO, discoverExternalPlugins, type DiscoveryIo, type ExternalPluginCandidate, type PluginDiscoveryResult, resolvePluginEntryPath, resolvePluginTarget, type SkippedPluginCandidate, } from './discovery.js';
 export { diffPluginConfig, type PluginConfigChange, type PluginConfigSource, type PluginEnablementSource, pluginEntryMatchesName, type ResolvePluginConfigInput, type ResolvePluginEnablementInput, type ResolvedPluginConfig, type ResolvedPluginEnablement, redactPluginConfig, resolvePluginConfig, resolvePluginEnablement, resolvePluginManifestConfig, validatePluginConfigMetadata, } from './config.js';
 export { KERNEL_API_VERSION, loadPlugins, type LoadPluginsOptions, type PluginHostHandle, type PluginLoadFailure, unloadPlugins, } from './loader.js';
+export { defaultPluginTrustPath, hashFileContents, normalizeTrustKey, type PluginTrustEntry, type PluginTrustStore, pinPluginTrust, readPluginTrustStore, unpinPluginTrust, verifyPluginTrust, type PluginTrustVerification, writePluginTrustStore, } from './trust.js';
 export type { PluginAPI } from '../types/plugin.js';
 export { buildReviewerModelPool, createAutoReviewPlugin, parseReviewSeverity, type ReviewerModelAssignment, selectRoundRobinReviewerAssignment, } from '../plugins/auto-review-plugin.js';
 export { type CascadeAgentKind, type CascadeEvidenceCheckResult, type CascadeEvidenceStatus, CHIMERA_REVIEW_PROMPT, createChimeraPlugin, type ChimeraCascadeNeededPayload, type ChimeraReviewCompletePayload, type ChimeraReviewNeededPayload, type ReviewContextBundle, } from '../plugins/chimera-plugin.js';

package/dist/plugin/index.js

@@ -217,7 +217,7 @@ var init_atomic_write = __esm({
 });
 
 // src/plugins/review-finding-types.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 function normalizeFingerprintTitle(title) {
   return title.trim().toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
 }
@@ -225,7 +225,7 @@ function computeFindingFingerprint(file, line, title) {
   const normalizedTitle = normalizeFingerprintTitle(title);
   const normalizedFile = file.replace(/\\/g, "/").trim().toLowerCase();
   const lineStr = line != null && line >= 0 ? String(line) : "0";
-  const hash = createHash8("sha256");
+  const hash = createHash9("sha256");
   hash.update(`${normalizedFile}:${lineStr}:${normalizedTitle}`);
   return hash.digest("hex");
 }
@@ -1664,7 +1664,8 @@ async function loadPlugins(plugins, opts) {
         plugin,
         resolution.options
       );
-      const api = plugin.capabilities ? wrapApiForCapabilityCheck(plugin, rawApi, opts.log, opts.enforceCapabilities) : rawApi;
+      const enforceForPlugin = typeof opts.enforceCapabilities === "function" ? opts.enforceCapabilities(plugin) : opts.enforceCapabilities ?? false;
+      const api = plugin.capabilities ? wrapApiForCapabilityCheck(plugin, rawApi, opts.log, enforceForPlugin) : rawApi;
       registration = {
         plugin,
         api,
@@ -2241,6 +2242,234 @@ function definePlugin(metadata, factory) {
   };
 }
 
+// src/plugin/discovery.ts
+var DEFAULT_PLUGIN_DISCOVERY_IO = {
+  async readdir(root) {
+    const { readdir: readdir8 } = await import("node:fs/promises");
+    return readdir8(root, { withFileTypes: true });
+  },
+  async stat(path35) {
+    const { stat: stat9 } = await import("node:fs/promises");
+    return stat9(path35);
+  },
+  async readFile(path35) {
+    const { readFile: readFile22 } = await import("node:fs/promises");
+    return readFile22(path35, "utf8");
+  }
+};
+var ENTRY_EXTENSIONS = [".js", ".mjs", ".cjs"];
+var SKIP_DIR_NAMES = /* @__PURE__ */ new Set(["node_modules"]);
+function isDotEntry(name) {
+  return name.startsWith(".");
+}
+function hasEntryExtension(name) {
+  return ENTRY_EXTENSIONS.some((ext) => name.endsWith(ext));
+}
+async function isFile(io, path35) {
+  try {
+    return (await io.stat(path35)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(io, path35) {
+  try {
+    return (await io.stat(path35)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function resolvePackageEntry(io, dir) {
+  const pkgPath = `${dir}/package.json`;
+  if (!await isFile(io, pkgPath)) {
+    return { entry: void 0, problem: void 0 };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await io.readFile(pkgPath));
+  } catch (err) {
+    return {
+      entry: void 0,
+      problem: `invalid package.json (${err instanceof Error ? err.message : String(err)})`
+    };
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    return { entry: void 0, problem: "package.json is not an object" };
+  }
+  const pkg = parsed;
+  const candidates = [];
+  const dotExport = pkg.exports?.["."];
+  if (typeof dotExport === "string") {
+    candidates.push(dotExport);
+  } else if (dotExport !== null && typeof dotExport === "object") {
+    const conditions = dotExport;
+    for (const key of ["import", "module", "default"]) {
+      const value = conditions[key];
+      if (typeof value === "string") candidates.push(value);
+    }
+  }
+  if (typeof pkg.main === "string" && pkg.main.length > 0) {
+    candidates.push(pkg.main);
+  }
+  for (const candidate of candidates) {
+    const normalized = candidate.startsWith(".") ? candidate : `./${candidate}`;
+    const base = `${dir}/${normalized.slice(2)}`;
+    if (await isFile(io, base)) return { entry: base, problem: void 0 };
+    for (const ext of ENTRY_EXTENSIONS) {
+      if (await isFile(io, `${base}${ext}`)) {
+        return { entry: `${base}${ext}`, problem: void 0 };
+      }
+    }
+  }
+  return {
+    entry: void 0,
+    problem: 'package.json declares no resolvable entry (checked main, exports["."], index fallbacks)'
+  };
+}
+async function resolvePluginEntryPath(dir, io = DEFAULT_PLUGIN_DISCOVERY_IO) {
+  const { entry: resolved } = await resolvePackageEntry(io, dir);
+  if (resolved) return resolved;
+  for (const ext of ENTRY_EXTENSIONS) {
+    const candidate = `${dir}/index${ext}`;
+    if (await isFile(io, candidate)) return candidate;
+  }
+  return null;
+}
+function canon(path35) {
+  return path35.replaceAll("\\", "/");
+}
+async function resolvePluginTarget(target, io = DEFAULT_PLUGIN_DISCOVERY_IO) {
+  if (await isFile(io, target)) return canon(target);
+  if (await isDirectory(io, target)) return resolvePluginEntryPath(canon(target), io);
+  return null;
+}
+async function discoverExternalPlugins(roots, io = DEFAULT_PLUGIN_DISCOVERY_IO) {
+  const candidates = [];
+  const skipped = [];
+  for (const root of roots) {
+    let entries;
+    try {
+      entries = await io.readdir(root);
+    } catch {
+      continue;
+    }
+    const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of sorted) {
+      if (isDotEntry(entry.name) || SKIP_DIR_NAMES.has(entry.name)) continue;
+      const full = canon(`${root}/${entry.name}`);
+      if (entry.isDirectory() || await isDirectory(io, full)) {
+        const resolved = await resolvePluginEntryPath(full, io);
+        if (resolved) {
+          candidates.push({ name: entry.name, entryPath: resolved, root });
+        } else {
+          skipped.push({
+            name: entry.name,
+            root,
+            reason: "no resolvable entry (package.json main/exports or index fallbacks)"
+          });
+        }
+      } else if (entry.isFile() && hasEntryExtension(entry.name)) {
+        candidates.push({
+          name: entry.name.slice(0, entry.name.length - extOf(entry.name).length),
+          entryPath: full,
+          root
+        });
+      }
+    }
+  }
+  return { candidates, skipped };
+}
+function extOf(name) {
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index);
+}
+
+// src/plugin/trust.ts
+init_errors();
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+function defaultPluginTrustPath(globalRoot) {
+  return join(globalRoot, "plugin-trust.json");
+}
+function normalizeTrustKey(path35) {
+  return path35.replaceAll("\\", "/");
+}
+async function hashFileContents(entryPath, readFileFn = defaultReadFile) {
+  const contents = await readFileFn(entryPath);
+  return `sha256-${createHash("sha256").update(contents).digest("hex")}`;
+}
+async function defaultReadFile(path35) {
+  return readFile(path35);
+}
+async function readPluginTrustStore(storePath, readFileFn = (path35) => readFile(path35, "utf8")) {
+  let raw;
+  try {
+    raw = await readFileFn(storePath);
+  } catch {
+    return { pinned: {} };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new FsError({
+      message: `Plugin trust store "${storePath}" is not valid JSON \u2014 fix or delete the file before loading external plugins (${err instanceof Error ? err.message : String(err)})`,
+      code: ERROR_CODES.FS_READ_FAILED,
+      path: storePath
+    });
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    throw new FsError({
+      message: `Plugin trust store "${storePath}" has an unexpected shape (expected { pinned: {...} }) \u2014 fix or delete the file`,
+      code: ERROR_CODES.FS_READ_FAILED,
+      path: storePath
+    });
+  }
+  const pinned = parsed.pinned;
+  if (pinned === void 0) return { pinned: {} };
+  if (pinned === null || typeof pinned !== "object" || Array.isArray(pinned)) {
+    throw new FsError({
+      message: `Plugin trust store "${storePath}" has an invalid "pinned" section \u2014 fix or delete the file`,
+      code: ERROR_CODES.FS_READ_FAILED,
+      path: storePath
+    });
+  }
+  return { pinned };
+}
+async function writePluginTrustStore(storePath, store) {
+  await mkdir(dirname(storePath), { recursive: true });
+  const tmp = `${storePath}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(store, null, 2)}
+`, { mode: 384 });
+  await rename(tmp, storePath);
+}
+function verifyPluginTrust(name, integrity, store) {
+  const pinned = store.pinned[name];
+  if (!pinned) return { status: "unpinned", integrity };
+  if (pinned.integrity === integrity) return { status: "trusted", integrity };
+  return {
+    status: "changed",
+    expected: pinned.integrity,
+    actual: integrity,
+    pinnedAt: pinned.pinnedAt
+  };
+}
+async function pinPluginTrust(storePath, name, entry, integrity, spec) {
+  const store = await readPluginTrustStore(storePath);
+  store.pinned[name] = { entry, integrity, pinnedAt: (/* @__PURE__ */ new Date()).toISOString(), spec };
+  await writePluginTrustStore(storePath, store);
+  return store;
+}
+async function unpinPluginTrust(storePath, name) {
+  const store = await readPluginTrustStore(storePath);
+  if (store.pinned[name] !== void 0) {
+    delete store.pinned[name];
+    await writePluginTrustStore(storePath, store);
+  }
+  return store;
+}
+
 // src/plugins/auto-review-plugin.ts
 init_error();
 import * as fsp3 from "node:fs/promises";
@@ -2899,7 +3128,7 @@ function shouldCascade(cascadeOn, severities) {
 
 // src/plugins/auto-review-git.ts
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
 var MAX_SNAPSHOT_FILE_BYTES = 256 * 1024;
@@ -2966,7 +3195,7 @@ async function snapshotChangedFiles(cwd) {
       snapshots.push({
         ...file,
         content,
-        fingerprint: createHash("sha256").update(content).digest("hex")
+        fingerprint: createHash2("sha256").update(content).digest("hex")
       });
     } catch {
     }
@@ -2975,7 +3204,7 @@ async function snapshotChangedFiles(cwd) {
 }
 
 // src/plugins/review-claim-registry.ts
-import { createHash as createHash2, randomUUID } from "node:crypto";
+import { createHash as createHash3, randomUUID } from "node:crypto";
 import * as fsp2 from "node:fs/promises";
 import { hostname } from "node:os";
 import * as path2 from "node:path";
@@ -3119,7 +3348,7 @@ var claimsByEventBus = /* @__PURE__ */ new WeakMap();
 var startedReviews = /* @__PURE__ */ new WeakMap();
 var pendingStartedReviews = /* @__PURE__ */ new WeakMap();
 function fingerprint(content) {
-  return createHash2("sha256").update(content).digest("hex");
+  return createHash3("sha256").update(content).digest("hex");
 }
 function normalizeKeyPart(p) {
   const forward = p.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -3474,7 +3703,7 @@ import * as os4 from "node:os";
 import * as path16 from "node:path";
 
 // src/utils/wstack-paths.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path3 from "node:path";
@@ -3500,12 +3729,12 @@ function canonicalProjectRoot(absRoot) {
   }
 }
 function projectHash(absRoot) {
-  return createHash3("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
+  return createHash4("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
 }
 function projectSlug(absRoot) {
   const identityRoot = canonicalProjectRoot(absRoot);
   const base = slugify(path3.basename(identityRoot));
-  const hash = createHash3("sha256").update(identityRoot).digest("hex").slice(0, 6);
+  const hash = createHash4("sha256").update(identityRoot).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
 function slugify(name) {
@@ -3613,7 +3842,7 @@ function resolveWstackPaths(opts) {
 }
 
 // src/chronicle/identity.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import * as os2 from "node:os";
 import * as path4 from "node:path";
 function resolveChronicleRuntimeLocation(input) {
@@ -3627,7 +3856,7 @@ function resolveChronicleRuntimeLocation(input) {
   };
 }
 function stableId(prefix, value) {
-  return `${prefix}_${createHash4("sha256").update(value).digest("hex").slice(0, 24)}`;
+  return `${prefix}_${createHash5("sha256").update(value).digest("hex").slice(0, 24)}`;
 }
 
 // src/chronicle/journal.ts
@@ -3640,7 +3869,7 @@ import * as path6 from "node:path";
 import { createInterface } from "node:readline";
 
 // src/chronicle/event-hash.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 var GENESIS_HASH = "0".repeat(64);
 function stableStringify(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
@@ -3651,7 +3880,7 @@ function stableStringify(value) {
   return `{${Object.keys(obj).sort().filter((key) => obj[key] !== void 0).map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",")}}`;
 }
 function hashValue(value) {
-  return createHash5("sha256").update(stableStringify(value), "utf8").digest("hex");
+  return createHash6("sha256").update(stableStringify(value), "utf8").digest("hex");
 }
 function chronicleEventHash(event) {
   const { hash: _hash, ...unhashed } = event;
@@ -4278,7 +4507,7 @@ import * as fs7 from "node:fs/promises";
 import * as path11 from "node:path";
 
 // src/chronicle/query.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
 import * as fs4 from "node:fs/promises";
 import * as path8 from "node:path";
@@ -4937,7 +5166,7 @@ function orderKey(event) {
 }
 function hashQuery(query) {
   const { cursor: _cursor, limit: _limit, order: _order, ...filters } = query;
-  return createHash6("sha256").update(stableStringify2(filters), "utf8").digest("base64url");
+  return createHash7("sha256").update(stableStringify2(filters), "utf8").digest("base64url");
 }
 function encodeCursor(cursor) {
   return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
@@ -4996,7 +5225,7 @@ async function resolveSnapshotFiles(files, snapshot) {
   }));
 }
 function fileId(file) {
-  return createHash6("sha256").update(path8.resolve(file), "utf8").digest("base64url");
+  return createHash7("sha256").update(path8.resolve(file), "utf8").digest("base64url");
 }
 function stableStringify2(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
@@ -5533,10 +5762,10 @@ function instructionRootCandidates() {
     path9.resolve(here, "../instructions"),
     path9.resolve(here, "instructions")
   ];
-  rootCandidates = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+  rootCandidates = candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
   return rootCandidates;
 }
-function isDirectory(candidate) {
+function isDirectory2(candidate) {
   try {
     return statSync3(candidate).isDirectory();
   } catch {
@@ -7400,7 +7629,7 @@ import * as path15 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/chronicle/project-server-endpoint.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import * as os3 from "node:os";
 import * as path14 from "node:path";
 
@@ -7419,7 +7648,7 @@ function normalizedPath(value) {
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function chronicleProjectServerKey(projectDir) {
-  return createHash7("sha256").update(normalizedPath(path14.join(projectDir, "chronicle"))).digest("hex").slice(0, 24);
+  return createHash8("sha256").update(normalizedPath(path14.join(projectDir, "chronicle"))).digest("hex").slice(0, 24);
 }
 function chronicleProjectServerEndpoint(projectDir) {
   const key = chronicleProjectServerKey(projectDir);
@@ -10925,7 +11154,7 @@ function resolveFindingPath(raw, cwd) {
 async function verifyFindingsAgainstDisk(findings, opts) {
   const window = opts.anchorWindow ?? DEFAULT_ANCHOR_WINDOW;
   const cache = /* @__PURE__ */ new Map();
-  const readFile21 = async (abs) => {
+  const readFile22 = async (abs) => {
     const cached = cache.get(abs);
     if (cached) return cached;
     let result;
@@ -10947,7 +11176,7 @@ async function verifyFindingsAgainstDisk(findings, opts) {
       if (abs === null) {
         return { ...finding, verification: { status: "failed", reason: "outside_workspace" } };
       }
-      const file = await readFile21(abs);
+      const file = await readFile22(abs);
       if ("error" in file) {
         return {
           ...finding,
@@ -12848,7 +13077,7 @@ init_atomic_write();
 init_errors();
 import * as fs18 from "node:fs/promises";
 import * as path31 from "node:path";
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 var ALL_SYNC_CATEGORIES = ["settings", "skills", "prompts", "memory", "history"];
 var CloudSync = class {
   constructor(paths, getConfig, setConfig, getSettingsConfigPath) {
@@ -13154,7 +13383,7 @@ var CloudSync = class {
       } catch {
       }
     }
-    const rev = createHash9("sha256").update(hashes.join("")).digest("hex").slice(0, 12);
+    const rev = createHash10("sha256").update(hashes.join("")).digest("hex").slice(0, 12);
     return { treeEntries: entries, rev };
   }
   async hashLocalCategories(categories) {
@@ -13179,7 +13408,7 @@ var CloudSync = class {
       } catch {
       }
     }
-    return createHash9("sha256").update(hashes.join("")).digest("hex").slice(0, 12);
+    return createHash10("sha256").update(hashes.join("")).digest("hex").slice(0, 12);
   }
   categoryToPath(cat) {
     switch (cat) {
@@ -13570,7 +13799,7 @@ function isSecretField(name) {
 
 // src/storage/cloud-config-sync.ts
 init_atomic_write();
-import { createHash as createHash10, randomUUID as nodeRandomUUID } from "node:crypto";
+import { createHash as createHash11, randomUUID as nodeRandomUUID } from "node:crypto";
 import * as fs19 from "node:fs/promises";
 import * as path33 from "node:path";
 
@@ -14031,7 +14260,7 @@ function stableStringify3(value) {
   return JSON.stringify(value) ?? "null";
 }
 function hashPayload(payload) {
-  return createHash10("sha256").update(stableStringify3(payload)).digest("hex");
+  return createHash11("sha256").update(stableStringify3(payload)).digest("hex");
 }
 function deepEquals(a, b) {
   return stableStringify3(a) === stableStringify3(b);
@@ -14519,6 +14748,7 @@ ${first}` };
 }
 export {
   CHIMERA_REVIEW_PROMPT,
+  DEFAULT_PLUGIN_DISCOVERY_IO,
   DefaultPluginAPI,
   KERNEL_API_VERSION,
   buildReviewerModelPool,
@@ -14529,26 +14759,37 @@ export {
   createPromptsPlugin,
   createSkillsPlugin,
   createSyncPlugin,
+  defaultPluginTrustPath,
   definePlugin,
   diffPluginConfig,
+  discoverExternalPlugins,
   emitReviewIfChanged,
+  hashFileContents,
   integrateFindings,
   loadPlugins,
   maybeCompactReviewStores,
+  normalizeTrustKey,
   parseChimeraReviewReport,
   parseReviewSeverity,
   persistReviewReport,
+  pinPluginTrust,
   pluginEntryMatchesName,
+  readPluginTrustStore,
   recordCompletedReview,
   recordStartedReview,
   redactPluginConfig,
   resolvePluginConfig,
   resolvePluginEnablement,
+  resolvePluginEntryPath,
   resolvePluginManifestConfig,
+  resolvePluginTarget,
   selectRoundRobinReviewerAssignment,
   unloadPlugins,
+  unpinPluginTrust,
   updateReviewReportEvidence,
   validatePluginConfigMetadata,
-  verifyFindingsAgainstDisk
+  verifyFindingsAgainstDisk,
+  verifyPluginTrust,
+  writePluginTrustStore
 };
 //# sourceMappingURL=index.js.map

package/dist/plugin/loader.d.ts

@@ -49,8 +49,12 @@ export interface LoadPluginsOptions {
      * method that contradicts its declared `capabilities` — instead of
      * just logging a warning. Use in CI/strict deployments to enforce
      * manifest honesty. Default: false (log-only, backward-compatible).
+     *
+     * A predicate form is also accepted so hosts can enforce selectively —
+     * e.g. strictly for external (third-party) plugins while keeping
+     * first-party plugins warn-only.
      */
-    enforceCapabilities?: boolean | undefined;
+    enforceCapabilities?: boolean | ((plugin: Plugin) => boolean) | undefined;
     /**
      * Timeout in milliseconds for each plugin's `setup()` call. If the
      * plugin's setup exceeds this deadline it is treated as a failure