@awebai/oats 0.25.8 → 0.26.0

package/lib/packages.mjs

@@ -1,5 +1,5 @@
 /**
- * OATS packages — versions, lock v3, approval (workspace model v2).
+ * OATS packages — versions, lock v3 (workspace model v2).
  *
  * Contract: docs/design/2026-09-23-workspace-module-contracts.md §4.
  * Decision: agents/oats-expert/soul/knowledge/decisions/workspace-model-v2.md.
@@ -7,9 +7,10 @@
  * A package is a place to fetch from WITH a version attached. Nothing is
  * installed: `resolvePackages` turns each `workspace.packages` entry into an
  * exact (commit, integrity) pair recorded in `oats-lock.json`
- * (lockfileVersion 3), and the one-time executable approval per version lives
- * next to the commit it approved. A moved tag (same version string, different
- * commit) fails integrity and asks again.
+ * (lockfileVersion 3). There is no approval step (human decision 2026-09-24):
+ * declaring a package in the workspace's `packages:` IS the trust decision. The
+ * lock is reproducibility — a moved tag (same version string, different commit)
+ * or drifted content fails integrity (E_PACKAGE_INTEGRITY).
  *
  * This module is synchronous except `resolvePackages`, shells out to nothing,
  * and depends only on `node:*`. Remote access is INJECTED (`remote` option) so
@@ -27,27 +28,13 @@
  *         version:      "<version string, no leading v>",
  *         commit:       "<full 40-hex OID>",
  *         integrity:    "sha256-<hex>",          // contentDigest of the package tree at <path>
- *         capabilities: ["<cap name>", …],        // sorted
- *         approved:     { executables: "sha256-<hex>", at: "<ISO-8601 UTC>" } | null
+ *         capabilities: ["<cap name>", …]         // sorted
  *       }
  *     }
  *   }
  *
- * `packageTree` (input of `executablesDigest`):
- *
- *   { manifests: [ { name: "<cap name>", manifest: <parsed oats.json>, files: Map<relpath, Buffer> } ] }
- *
- *   `files` holds the bytes of the capability directory, keyed by POSIX
- *   relative path from that directory (e.g. "bin/tool.mjs"). Each
- *   `manifest.commands[<cmd>]` value is "<relpath> [args…]"; the FIRST token is
- *   the executable target whose bytes are digested. Only command targets are
- *   digested — skills, injects and other files are covered by `integrity`.
- *
- * `executablesDigestAt(remote, ref, commit, path, capabilities?)` is the ONE shared
- * computation of that digest over a remote tree at a commit: `oats sync` approves
- * what it returns, `resolveSoul` requires equality with `approved.executables` at
- * spawn (E_PACKAGE_UNAPPROVED reason "digest-mismatch"). An edited lock — same
- * id/version, different commit, copied approval — can therefore never materialize.
+ * A lock written before 0.26.0 may still carry an `approved` record per entry:
+ * it is read with the field ignored, and the next write drops it.
  *
  * Deprecated shims: every name the 0.24 kernel still imports from this module
  * is exported below as a thin function throwing E_REMOVED so nothing breaks at
@@ -56,9 +43,9 @@
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync, lstatSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
-import { createHash } from "node:crypto";
 import { oatsError as baseOatsError } from "./errors.mjs";
 import * as defaultRemote from "./remote.mjs";
+import { manifestContractProblems } from "./capability-contract.mjs";
 
 export const LOCK_FILE = "oats-lock.json";
 export const LOCK_VERSION = 3;
@@ -156,11 +143,6 @@ export function validateLock(lock, { file } = {}) {
     if (typeof entry.commit !== "string" || !OID_RE.test(entry.commit)) throw bad("commit", "must be a full 40-hex OID");
     if (typeof entry.integrity !== "string" || !DIGEST_RE.test(entry.integrity)) throw bad("integrity", "must be sha256-<hex>");
     if (!Array.isArray(entry.capabilities) || entry.capabilities.some((c) => typeof c !== "string" || !c)) throw bad("capabilities", "must be an array of capability names");
-    if (entry.approved !== null) {
-      if (!plainObject(entry.approved)) throw bad("approved", "must be null or { executables, at }");
-      if (typeof entry.approved.executables !== "string" || !DIGEST_RE.test(entry.approved.executables)) throw bad("approved/executables", "must be sha256-<hex>");
-      if (typeof entry.approved.at !== "string" || Number.isNaN(Date.parse(entry.approved.at))) throw bad("approved/at", "must be an ISO-8601 timestamp");
-    }
   }
   return lock;
 }
@@ -186,7 +168,6 @@ export function canonicalLock(lock) {
     packages[id] = {
       source: e.source, ...(typeof e.url === "string" && e.url ? { url: e.url } : {}), path: e.path, version: e.version, commit: e.commit, integrity: e.integrity,
       capabilities: [...e.capabilities].sort(),
-      approved: e.approved ? { executables: e.approved.executables, at: e.approved.at } : null,
     };
   }
   return { lockfileVersion: LOCK_VERSION, packages };
@@ -332,6 +313,8 @@ export async function readPackageManifests(remote, remoteRef, commit, path, deta
     if (seen.has(capManifest.capability)) {
       throw oatsError("E_PACKAGE_MANIFEST", `package ${manifest.package} declares capability ${JSON.stringify(capManifest.capability)} twice (${seen.get(capManifest.capability)} and ${dir})`, { ...details, path: dir, duplicate: capManifest.capability, other: seen.get(capManifest.capability) });
     }
+    const [problem] = manifestContractProblems(capManifest);
+    if (problem) throw oatsError("E_PACKAGE_MANIFEST", `${pjoin(dir, CAPABILITY_MANIFEST)}#${problem.pointer}: ${problem.message}`, { ...details, path: dir, capability: capManifest.capability, pointer: problem.pointer });
     seen.set(capManifest.capability, dir);
     capabilities.push({ name: capManifest.capability, dir, manifest: capManifest });
   }
@@ -354,83 +337,6 @@ async function packageIntegrity(remote, remoteRef, commit, path) {
   } finally { rmSync(scratch, { recursive: true, force: true }); }
 }
 
-/** Depth bound for reading a capability directory: deep enough for any real layout. */
-export const PACKAGE_TREE_DEPTH = 64;
-
-/** Build a `packageTree` (see module header) for `executablesDigest` from the remote.
- * Reads every blob under each capability directory. */
-export async function readPackageTree(remote, remoteRef, commit, path, { depth = PACKAGE_TREE_DEPTH, remoteOptions } = {}) {
-  remote = bindRemote(remote, remoteOptions);
-  const { capabilities } = await readPackageManifests(remote, remoteRef, commit, path);
-  const manifests = [];
-  for (const cap of capabilities) {
-    const listing = await remote.listRemoteTree(remoteRef, commit, cap.dir, { depth });
-    const files = new Map();
-    for (const item of listing) {
-      if (item.type !== "blob") continue;
-      const { bytes } = await remote.readRemoteFile(remoteRef, commit, pjoin(cap.dir, item.path));
-      files.set(item.path, Buffer.from(bytes));
-    }
-    manifests.push({ name: cap.name, manifest: cap.manifest, files });
-  }
-  return { manifests };
-}
-
-/**
- * The executables digest of a locked package AT A COMMIT, read over the remote — the ONE definition
- * `oats sync` (approval) and `resolveSoul` (the gate at spawn) share, so what was approved is exactly what
- * is checked. `remote` is a contract-§1 remote (default lib/remote.mjs; `remoteOptions` bound here).
- *
- *   executablesDigestAt(remote, ref, commit, path, capabilities?, { remoteOptions } = {})
- *   → { digest: "sha256-…", executables: [{ capability, kind, name, target }], capabilities: [<names>] }  (frozen)
- *
- * `capabilities` (optional, the lock entry's list) is checked against what `<path>/oats-package.json`
- * declares at `commit`: a mismatch is E_PACKAGE_INTEGRITY { why: "capabilities", listed, locked } — a lock
- * whose capability list drifted from the tree it names is not describing that tree.
- *
- * Cached per process by (remote identity, repo key, commit, path): a commit is content-addressed, so the
- * tree — and its digest — can never change under the same OID. The cache is keyed on the remote OBJECT
- * (WeakMap): a test's fake remote gets its own cache and never sees another test's tree; the kernel's
- * default remote keeps one cache for the process (sync → many spawns of the same lock).
- */
-const digestCache = new WeakMap();
-export async function executablesDigestAt(remote, ref, commit, path, capabilities = null, { remoteOptions } = {}) {
-  if (!remote || typeof remote.readRemoteFile !== "function" || typeof remote.listRemoteTree !== "function") {
-    throw new TypeError("executablesDigestAt: remote must provide readRemoteFile()/listRemoteTree() (module contract §1)");
-  }
-  if (typeof commit !== "string" || !OID_RE.test(commit)) throw oatsError("E_PACKAGE_INTEGRITY", `executablesDigestAt: commit must be a full 40-hex OID, got ${JSON.stringify(commit)}`, { commit, path });
-  if (capabilities !== null && (!Array.isArray(capabilities) || capabilities.some((c) => typeof c !== "string"))) throw new TypeError("executablesDigestAt: capabilities must be an array of names or null");
-  const parse = typeof remote.parseRepoRef === "function" ? remote.parseRepoRef : defaultRemote.parseRepoRef;
-  let repoKey; try { repoKey = parse(ref).key; } catch { repoKey = String(ref); }
-  const cacheKey = `${repoKey}\0${commit}\0${path}`;
-  let perRemote = digestCache.get(remote);
-  if (!perRemote) { perRemote = new Map(); digestCache.set(remote, perRemote); }
-  let pending = perRemote.get(cacheKey);
-  if (!pending) {
-    pending = (async () => {
-      const tree = await readPackageTree(remote, ref, commit, path, { remoteOptions });
-      const digest = executablesDigest(tree);
-      const executables = [];
-      for (const m of [...tree.manifests].sort((a, b) => byCodepoint(String(a.name), String(b.name)))) {
-        for (const x of manifestExecutables(m.manifest)) executables.push({ capability: m.name, kind: x.kind, name: x.name, target: x.target });
-      }
-      return Object.freeze({ digest, executables: Object.freeze(executables.map((x) => Object.freeze(x))), capabilities: Object.freeze(tree.manifests.map((m) => m.name).sort(byCodepoint)) });
-    })();
-    perRemote.set(cacheKey, pending);
-    // A failed read is not cached: the next caller retries (a transient remote failure must not pin an error).
-    pending.catch(() => { if (perRemote.get(cacheKey) === pending) perRemote.delete(cacheKey); });
-  }
-  const result = await pending;
-  if (capabilities !== null) {
-    const locked = [...capabilities].sort(byCodepoint);
-    const listed = result.capabilities;
-    if (locked.length !== listed.length || locked.some((c, i) => c !== listed[i])) {
-      throw oatsError("E_PACKAGE_INTEGRITY", `the lock lists capabilities [${locked.join(", ")}] for ${path} at ${commit.slice(0, 12)}, but the package there declares [${listed.join(", ")}]`, { why: "capabilities", commit, path, listed: [...listed], locked });
-    }
-  }
-  return result;
-}
-
 // ---------- resolvePackages ----------
 
 function assertDigest(what, value, details) {
@@ -463,14 +369,11 @@ export function bindRemote(remote, remoteOptions) {
  *                  lib/remote.mjs; tests pass an in-memory fake. options.remoteOptions (cacheDir, exec, …)
  *                  is threaded into every remote call.
  *
- * → { lock, changes: [{ id, from, to, commit, approvalNeeded }] }
+ * → { lock, changes: [{ id, from, to, commit }] }
  *   - `from` is the previously locked version or null; `to` is the resolved version
  *     (null when the package was removed from the workspace and dropped from the lock).
- *   - `approvalNeeded` = the entry's `approved` is null.
  *   - A locked entry whose version string is unchanged but whose commit or
  *     integrity moved → E_PACKAGE_INTEGRITY { id, version, locked, observed }.
- *   - Unchanged entries keep their approval ONLY when the recorded executables digest still
- *     matches the tree (else E_PACKAGE_UNAPPROVED); a new version starts unapproved.
  *   - A value resolving to a BRANCH → E_PACKAGE_INTEGRITY { why: "branch" }: versions are immutable.
  */
 export async function resolvePackages(workspace, { catalog = {}, lock = emptyLock(), remote = defaultRemote, remoteOptions } = {}) {
@@ -513,16 +416,18 @@ export async function resolvePackages(workspace, { catalog = {}, lock = emptyLoc
           `packages.${id} ${version} @ ${obs.commit}: content digest ${integrity} does not match the locked ${old.integrity}`,
           { ...details, version, locked: { commit: old.commit, integrity: old.integrity }, observed: { commit: obs.commit, integrity } });
       }
-      // A recorded approval must describe THESE executables, not merely any well-formed digest.
-      if (old.approved) {
-        const { digest: executables } = await executablesDigestAt(remote, req.remoteRef, obs.commit, old.path);
-        if (executables !== old.approved.executables) {
-          throw oatsError("E_PACKAGE_UNAPPROVED",
-            `packages.${id} ${version}: the recorded approval ${old.approved.executables} does not match the package's executables ${executables} — approve again`,
-            { ...details, version, commit: obs.commit, approved: old.approved, executables });
-        }
+      // The lock's capability list must still be what the package declares at that commit —
+      // spawn refuses a mismatch (E_PACKAGE_INTEGRITY why:capabilities), so sync must too, or
+      // a bad list would pass every sync and fail every spawn.
+      const { capabilities } = await readPackageManifests(remote, req.remoteRef, obs.commit, old.path, details);
+      const listed = capabilities.map((c) => c.name).sort(), locked = [...old.capabilities].sort();
+      if (listed.length !== locked.length || listed.some((c, i) => c !== locked[i])) {
+        throw oatsError("E_PACKAGE_INTEGRITY",
+          `packages.${id} ${version} @ ${obs.commit}: the lock lists capabilities [${locked.join(", ")}] but the package declares [${listed.join(", ")}] — the lock was edited; remove this entry from oats-lock.json and run \`oats sync\` again`,
+          { ...details, version, why: "capabilities", listed, locked });
       }
-      nextPackages[id] = clone(old);
+      const { approved: _dropped, ...kept } = clone(old); // a pre-0.26 approval record is dropped on write
+      nextPackages[id] = kept;
       continue;
     }
 
@@ -531,87 +436,17 @@ export async function resolvePackages(workspace, { catalog = {}, lock = emptyLoc
     nextPackages[id] = {
       source, url: obs.url, path: req.path, version, commit: obs.commit, integrity,
       capabilities: capabilities.map((c) => c.name).sort(),
-      approved: null,
     };
-    changes.push({ id, from: old ? old.version : null, to: version, commit: obs.commit, approvalNeeded: true });
+    changes.push({ id, from: old ? old.version : null, to: version, commit: obs.commit });
   }
 
   for (const id of Object.keys(previous.packages).sort()) {
-    if (!(id in requests)) changes.push({ id, from: previous.packages[id].version, to: null, commit: null, approvalNeeded: false });
+    if (!(id in requests)) changes.push({ id, from: previous.packages[id].version, to: null, commit: null });
   }
 
   return { lock: { lockfileVersion: LOCK_VERSION, packages: sortedObject(nextPackages) }, changes };
 }
 
-// ---------- executables digest + approval ----------
-
-/** First token of a `commands` value is the executable target (e.g. "bin/x.mjs cut" → "bin/x.mjs"). */
-export function commandTarget(specification) {
-  return String(specification).trim().split(/\s+/)[0] || "";
-}
-
-/** Every executable a manifest can make the kernel run: `commands.*` targets AND `hooks.*.command`
- * targets (hooks run automatically at spawn/retire — the executables an approver most needs to see).
- * → [{ kind: "command"|"hook", name, target }] in canonical order. */
-export function manifestExecutables(manifest) {
-  const out = [];
-  const commands = plainObject(manifest?.commands) ? manifest.commands : {};
-  for (const cmd of Object.keys(commands).sort(byCodepoint)) out.push({ kind: "command", name: cmd, target: commandTarget(commands[cmd]), spec: commands[cmd] });
-  const hooks = plainObject(manifest?.hooks) ? manifest.hooks : {};
-  for (const hook of Object.keys(hooks).sort(byCodepoint)) {
-    // A hook is { command, ... } (schema: required command) or a bare string. A hook object WITHOUT
-    // `command` is malformed — it enters the list with spec undefined so executablesDigest refuses it
-    // (E_PACKAGE_MANIFEST), never an invisible no-op an approver does not see.
-    const spec = plainObject(hooks[hook]) ? hooks[hook].command : hooks[hook];
-    out.push({ kind: "hook", name: hook, target: spec === undefined || spec === null ? "" : commandTarget(spec), spec });
-  }
-  return out;
-}
-
-/**
- * sha256 over every capability manifest's executables' bytes — `commands` targets and
- * `hooks.*.command` targets — in canonical codepoint order (manifest name, kind, entry name).
- * Locale-independent: the same tree digests identically on every machine.
- * Input is a `packageTree` (module header). A target missing from `files` →
- * E_PACKAGE_MANIFEST { capability, command, target }. Empty set → the digest of nothing.
- */
-export function executablesDigest(packageTree) {
-  if (!plainObject(packageTree) || !Array.isArray(packageTree.manifests)) {
-    throw oatsError("E_PACKAGE_MANIFEST", "executablesDigest expects { manifests: [{ name, manifest, files }] }", { path: "/manifests" });
-  }
-  const hash = createHash("sha256");
-  const manifests = [...packageTree.manifests].sort((a, b) => byCodepoint(String(a.name), String(b.name)));
-  for (const { name, manifest, files } of manifests) {
-    for (const { kind, name: entry, target, spec } of manifestExecutables(manifest)) {
-      const label = kind === "hook" ? `hooks.${entry}.command` : `commands.${entry}`;
-      const details = { capability: name, command: entry, kind, target };
-      if (typeof spec !== "string") throw oatsError("E_PACKAGE_MANIFEST", `${name}: ${label} must be a string, got ${typeof spec}`, details);
-      assertRelPath(`${name} ${label}`, target, details);
-      const bytes = files instanceof Map ? files.get(target) : (plainObject(files) && Object.hasOwn(files, target) ? files[target] : undefined);
-      if (bytes === undefined) throw oatsError("E_PACKAGE_MANIFEST", `${name}: ${label} targets ${target}, which is not in the package`, details);
-      const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
-      // Hooks enter the framing under "hooks.<name>" so a hook and a command of the same name never collide.
-      hash.update(`${name}\0${kind === "hook" ? `hooks.${entry}` : entry}\0${target}\0${buf.length}\0`);
-      hash.update(buf);
-      hash.update("\0");
-    }
-  }
-  return `sha256-${hash.digest("hex")}`;
-}
-
-/** Record the executable approval for package `id`. Returns a NEW lock; the input is untouched. */
-export function approve(lock, id, digest, at = new Date().toISOString()) {
-  validateLock(lock);
-  const entry = lock.packages[id];
-  if (!entry) throw oatsError("E_PACKAGE_MISSING", `cannot approve ${JSON.stringify(id)}: not in the lock — run \`oats sync\` first`, { id });
-  if (typeof digest !== "string" || !DIGEST_RE.test(digest)) throw oatsError("E_PACKAGE_INTEGRITY", `approval digest for ${id} must be sha256-<hex>`, { id, digest });
-  const ms = Date.parse(at);
-  if (Number.isNaN(ms)) throw oatsError("E_LOCK_SCHEMA", `approval timestamp for ${id} is not ISO-8601: ${JSON.stringify(at)}`, { id, at });
-  const next = clone(lock);
-  next.packages[id] = { ...next.packages[id], approved: { executables: digest, at: new Date(ms).toISOString() } };
-  return next;
-}
-
 /** Which locked package provides capability `capName`? → { id, entry } | null.
  * Two packages providing the same name is ambiguous and fails closed:
  * E_PACKAGE_MISSING { capability, ambiguous: [ids] } — never a silent first-by-id pick. */

package/lib/provider-binding.mjs

@@ -1,10 +1,12 @@
 /** Provider-owned binding protocol. This codec declares no provider model and
  * grants no execution authority; commands remain in the sole manifest table. */
-import { objectAt, stringAt, stringSetAt, versionAt } from './portable-shape.mjs';
-import { FUNDAMENTAL_SLOTS } from './portable-policy.mjs';
+import { objectAt, stringAt, stringSetAt, versionAt } from './shape.mjs';
 import { oatsError } from './errors.mjs';
 import { validateBindingReasons } from './provider-reasons.mjs';
 
+/** The layers a binding codec may belong to (the kernel's LAYERS). */
+const FUNDAMENTAL_SLOTS = Object.freeze(['knowledge', 'messaging', 'tasks']);
+
 export const BINDING_PHASES = Object.freeze(['normalize', 'bind', 'check']);
 export function validateBindingInterface(manifest) {
   if (manifest.binding === undefined) return null;

package/lib/provider-reasons.mjs

@@ -1,60 +1,6 @@
-/** Fixed provider-declared diagnostics, never a free-text transport. Values
- * come from the verified selected manifest or reviewed kernel compatibility
- * data, not from a codec response, operator input or today's configuration. */
-import { invalidShape, stringAt, stringSetAt } from './portable-shape.mjs';
-
-// Compatibility literals for manifests predating binding.reasons. These are
-// data, never provider-name-dependent interpretation of payloads or settings.
-// aweb: awebai/oats-aweb v1.11.0, 862f156c883ab39c69c9e83cdf3bab86be882867.
-// oats-package/capabilities/oats-aweb/lib/{binding-wire,session-readiness}.mjs:
-// complete safeReasons/fallback/overflow/check vocabulary (no hook warnings).
-// OKF: awebai/oats-okf PR5, 0517a70a7158ebdf14ccb6e880b437c3d43cb1db,
-// same capability-relative file, settingMessages (UNRELEASED 2.1.2 at selection).
-// Released OKF 2.1.1 sends code-only; this table invents no reason for it.
-const bundled = Object.freeze({
-  'oats.aweb': Object.freeze([
-    'messaging-enabled standalone preparation needs an explicit context key',
-    'messaging binding needs one soul declaration',
-    'messaging workspace must declare private: per-human',
-    'an explicit responsible-human binding is required',
-    'an explicit wider-membership consent list is required',
-    'a selected wider-team binding is required',
-    'a selected wider alias needs an explicit workspace team mapping',
-    'multiple soul messaging declarations',
-    'adoption team aliases have conflicting mappings',
-    'messaging settings and explicit binding selections are required',
-    'messaging declarations contain incompatible requirements',
-    'messaging input must match the supported binding contract',
-    'explicit native messaging authorization is required',
-    'a required native messaging host resource is unavailable',
-    'the selected messaging provider is unavailable',
-    'the requested messaging configuration is not qualified',
-    'messaging response exceeds the supported wire limits',
-    'an admitted captured instance intent is required for execution',
-    'an explicit private-team binding is required',
-    'selected binding and inline captured invocation are required',
-    'an explicit captured instance home is required',
-    'captured messaging requires explicit delivery: session',
-    'selected wider memberships need their explicitly qualified native setup; they were not omitted',
-    'caller-owned OATS_CLI_BIN and readable kernel version are required',
-    'oats >=0.24.2 is required for captured HOME custody and retained runtime inspection',
-    'the exact retained runtime profile must be readable',
-    'the kernel must report the exact retained resolution',
-    'a retained launchSelection runtime/model observation is required',
-    'Pi strict print does not support session input; retain messaging and configure an input-capable profile',
-    'a supported input-capable ordinary Claude/Codex profile is required',
-  ]),
-  'oats.okf': Object.freeze([
-    'setting bindings-file is required (absolute host path)',
-    'setting bindings-file must be a normalized absolute host path',
-    'setting state-dir is required (absolute host path)',
-    'setting state-dir must be a normalized absolute host path',
-    'setting harvest-runtime is required (pi, claude or codex)',
-    'setting harvest-runtime must be pi, claude or codex',
-    'setting harvest-model must be null or a non-empty string',
-  ]),
-});
-const none = Object.freeze([]);
+/** Fixed provider-declared diagnostics (a manifest's binding.reasons), never a
+ * free-text transport: their shape and bounds. */
+import { invalidShape, stringAt, stringSetAt } from './shape.mjs';
 
 export function validateBindingReasons(reasons, { allowEmpty = false } = {}) {
   stringSetAt(reasons, '/binding/reasons', (reason, pointer) => {
@@ -64,14 +10,3 @@ export function validateBindingReasons(reasons, { allowEmpty = false } = {}) {
   if (reasons.length > 64 || (!allowEmpty && reasons.length === 0)) invalidShape('/binding/reasons', 'expected 1 to 64 fixed reasons');
   return reasons;
 }
-
-export function providerReasons(manifest) {
-  if (Object.hasOwn(manifest.binding ?? {}, 'reasons')) return validateBindingReasons(manifest.binding.reasons);
-  return Object.hasOwn(bundled, manifest.capability) ? bundled[manifest.capability] : none;
-}
-
-/** Exact Unicode scalar text is exact UTF-8 text; never trim, normalize,
- * interpolate or accept a prefix/substring. Absence preserves template fallback. */
-export function safeProviderReason(message, reasons) {
-  return typeof message === 'string' && reasons.includes(message) ? message : undefined;
-}