@kybernesis/kyberagent-extension-sdk 0.1.0-alpha

package/dist/testing/index.js

@@ -0,0 +1,967 @@
+import {
+  SeamPermissionDenied,
+  clearRawContributionIdUsages,
+  defineComposerCapability,
+  defineContextualAction,
+  defineDataEndpoint,
+  defineExtension,
+  defineSurface,
+  emitExtensionContributionSet,
+  gatedHostPort,
+  makeAgentId,
+  makeSeamCallContext,
+  parseContributionId,
+  rawContributionIdUsages,
+  requiresHostCapabilities,
+  requiresKernelPermissions,
+  validateDefinitionCrossRefs
+} from "../chunk-ZDAZ7Q2A.js";
+
+// src/testing/in-memory-host.ts
+var InMemoryBrainProvider = class {
+  constructor(seed = {}) {
+    this.seed = seed;
+  }
+  seed;
+  async stats() {
+    return { entities: this.seed.entities?.length ?? 0, notes: this.seed.notes?.length ?? 0 };
+  }
+  async query(text, opts) {
+    const needle = text.trim().toLowerCase();
+    const hits = (this.seed.entities ?? []).filter((entity) => entity.title.toLowerCase().includes(needle)).map((entity, index) => ({ id: entity.id, title: entity.title, score: Number((1 - index * 0.1).toFixed(2)) }));
+    return typeof opts?.limit === "number" ? hits.slice(0, opts.limit) : hits;
+  }
+};
+var InMemoryHost = class {
+  brains = /* @__PURE__ */ new Map();
+  constructor(seed = {}) {
+    for (const [agentName, agentBrain] of Object.entries(seed)) {
+      this.brains.set(agentName, new InMemoryBrainProvider(agentBrain));
+    }
+  }
+  brain(agentName) {
+    let provider = this.brains.get(agentName);
+    if (!provider) {
+      provider = new InMemoryBrainProvider();
+      this.brains.set(agentName, provider);
+    }
+    return provider;
+  }
+  /**
+   * Inject a gated, ctx-bound `HostPort` — the GROWN contract an extension actually
+   * consumes (red-team A1/A3; P5-PORTS-1 brought forward as conformance-prep). The
+   * runner builds the raw port from this host's in-memory state, binds the active
+   * agent from `ctx`, then wraps it in `gatedHostPort(grants)` — the SAME gate
+   * production uses (SDK-N3). This is what makes C9 ("green against InMemoryHost")
+   * a real conformance check instead of a vacuous one.
+   */
+  inject(ctx, grants) {
+    const raw = {
+      ctx,
+      brain: this.brain(ctx.activeAgent),
+      context: makeInMemoryContextPort(ctx),
+      command: IN_MEMORY_COMMAND_PORT
+      // events omitted (ext-owned; supplied by the extension, not the host) — docs/63 D6
+    };
+    return gatedHostPort(raw, grants);
+  }
+};
+function makeInMemoryContextPort(ctx) {
+  return { snapshot: async () => ({ activeAgent: ctx.activeAgent }) };
+}
+var IN_MEMORY_COMMAND_PORT = {
+  describe: async () => [],
+  invoke: async (commandId, args) => ({
+    ok: true,
+    data: { invoked: commandId, args: args ?? {} }
+  })
+};
+
+// src/testing/conformance.ts
+var ALL_GRANTS = /* @__PURE__ */ new Set([
+  "brain.read",
+  "host.context.read",
+  "host.command.invoke"
+]);
+var NO_GRANTS = /* @__PURE__ */ new Set();
+var GETTER_PERMISSION = {
+  brain: "brain.read",
+  context: "host.context.read",
+  command: "host.command.invoke"
+};
+function ctxFor(principal2, agent) {
+  return makeSeamCallContext({ principal: principal2, activeAgent: makeAgentId(agent), requestedAtMs: 0 });
+}
+function instrument(port) {
+  const touched = /* @__PURE__ */ new Set();
+  const wrapped = {
+    ctx: port.ctx,
+    get brain() {
+      touched.add(GETTER_PERMISSION.brain);
+      return port.brain;
+    },
+    get context() {
+      touched.add(GETTER_PERMISSION.context);
+      return port.context;
+    },
+    get command() {
+      touched.add(GETTER_PERMISSION.command);
+      return port.command;
+    },
+    events: port.events
+  };
+  return { port: wrapped, touched };
+}
+var EXERCISE_QUERY = { filter: { q: "" }, limit: 5 };
+var EXERCISE_DESCRIBE = {};
+var EXERCISE_INVOKE = { commandId: "conformance.noop", args: { q: "" } };
+async function exercise(port, ctx) {
+  const out = {};
+  const p = port;
+  if (typeof p.query === "function") out.rows = await p.query(EXERCISE_QUERY, ctx);
+  if (typeof p.describe === "function") await p.describe(EXERCISE_DESCRIBE, ctx);
+  if (typeof p.invoke === "function") out.response = await p.invoke(EXERCISE_INVOKE, ctx);
+  return out;
+}
+async function collectUsage(subject, host) {
+  const ctx = ctxFor(subject.principal, "k-brain");
+  const { port, touched } = instrument(host.inject(ctx, ALL_GRANTS));
+  const contributions = subject.activate(port);
+  for (const ans of contributions.values()) {
+    try {
+      await exercise(ans, ctx);
+    } catch {
+    }
+  }
+  return touched;
+}
+function declaredHostPermissions(definition) {
+  const gated = new Set(Object.values(GETTER_PERMISSION));
+  return new Set((definition.permissions ?? []).filter((p) => gated.has(p)));
+}
+function firstDataEndpoint(contributions) {
+  for (const [id, port] of contributions) {
+    if (id.startsWith("data.")) return port;
+  }
+  return void 0;
+}
+var CHECKS = [
+  {
+    id: "C1",
+    title: "injection only \u2014 host reached only through the injected port",
+    disposition: "enforced",
+    open: "Inject a host port with ZERO grants and exercise the extension.",
+    brokenIf: "host-derived data comes back without going through the gated port (a reach for a global).",
+    async run({ subjects, negatives, host }) {
+      const notes = [];
+      const check = async (s) => {
+        const ctx = ctxFor(s.principal, "k-brain");
+        const port = host.inject(ctx, NO_GRANTS);
+        const contributions = s.activate(port);
+        let obtainedUngated = false;
+        for (const ans of contributions.values()) {
+          try {
+            const out = await exercise(ans, ctx);
+            const rowsBrainy = (out.rows ?? []).some((r) => "title" in r || "top" in r || "noteCount" in r);
+            const respBrainy = out.response?.ok === true && typeof out.response.data === "object" && out.response.data !== null && "activeAgent" in out.response.data;
+            if (rowsBrainy || respBrainy) obtainedUngated = true;
+          } catch (err) {
+            if (!(err instanceof SeamPermissionDenied)) throw err;
+          }
+        }
+        return { obtainedUngated };
+      };
+      for (const s of subjects) {
+        if (declaredHostPermissions(s.definition).size === 0) continue;
+        const { obtainedUngated } = await check(s);
+        if (obtainedUngated) notes.push(`${s.name}: returned host data with no grants \u2014 reached past the injected port`);
+      }
+      for (const s of negatives) {
+        const { obtainedUngated } = await check(s);
+        if (!obtainedUngated) notes.push(`negative ${s.name}: expected a global-reach violation, none detected`);
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C2",
+    title: "context honoured \u2014 agent-scoped reads use ctx.activeAgent",
+    disposition: "enforced",
+    open: "Run the data endpoint under two different active agents (seeded differently).",
+    brokenIf: "the result is identical across agents (a re-derived/default agent, not ctx.activeAgent).",
+    async run({ subjects, negatives, host }) {
+      const notes = [];
+      const varies = async (s) => {
+        const a = ctxFor(s.principal, "k-brain");
+        const b = ctxFor(s.principal, "arcana");
+        const portA = firstDataEndpoint(s.activate(host.inject(a, ALL_GRANTS)));
+        const portB = firstDataEndpoint(s.activate(host.inject(b, ALL_GRANTS)));
+        if (!portA || !portB) return void 0;
+        const ra = JSON.stringify((await exercise(portA, a)).rows ?? []);
+        const rb = JSON.stringify((await exercise(portB, b)).rows ?? []);
+        return ra !== rb;
+      };
+      for (const s of subjects) {
+        const v = await varies(s);
+        if (v === false) notes.push(`${s.name}: data endpoint returned identical rows across agents \u2014 ignores ctx.activeAgent`);
+      }
+      for (const s of negatives) {
+        const v = await varies(s);
+        if (v !== false) notes.push(`negative ${s.name}: expected agent-blind output, but it varied (or had no data endpoint)`);
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C3",
+    title: "declarations match usage \u2014 declared permissions \u21D4 host-port calls",
+    disposition: "enforced",
+    open: "Diff the declared host permissions against the getters the run actually touches.",
+    brokenIf: "a declared permission is never used, or a used getter was never declared.",
+    async run({ subjects, negatives, host }) {
+      const notes = [];
+      const mismatch = async (s) => {
+        const declared = declaredHostPermissions(s.definition);
+        const used = await collectUsage(s, host);
+        const unusedDecl = [...declared].filter((p) => !used.has(p));
+        const undeclUsed = [...used].filter((p) => !declared.has(p));
+        if (unusedDecl.length || undeclUsed.length) {
+          return `declared-not-used=[${unusedDecl.join(",")}] used-not-declared=[${undeclUsed.join(",")}]`;
+        }
+        return null;
+      };
+      for (const s of subjects) {
+        const m = await mismatch(s);
+        if (m) notes.push(`${s.name}: ${m}`);
+      }
+      for (const s of negatives) {
+        const m = await mismatch(s);
+        if (!m) notes.push(`negative ${s.name}: expected a declaration/usage mismatch, found none`);
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C4",
+    title: "identity from context \u2014 never read extensionId from a payload",
+    disposition: "enforced",
+    open: "Probe identity with a FORGED extensionId in the payload; compare to ctx.principal.id.",
+    brokenIf: "the extension reports the forged payload id instead of ctx.principal.id.",
+    run({ subjects, negatives }) {
+      const notes = [];
+      const FORGED = "plugin.forged-impostor";
+      for (const s of subjects) {
+        const ctx = ctxFor(s.principal, "k-brain");
+        const reported = s.identityProbe(ctx, FORGED);
+        if (reported !== ctx.principal.id) notes.push(`${s.name}: reported identity "${reported}" \u2260 ctx.principal.id "${ctx.principal.id}"`);
+      }
+      for (const s of negatives) {
+        const ctx = ctxFor(s.principal, "k-brain");
+        const reported = s.identityProbe(ctx, FORGED);
+        if (reported === ctx.principal.id) notes.push(`negative ${s.name}: expected it to trust the forged payload id, but it used ctx`);
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C5",
+    title: "gated access fails typed \u2014 missing grant \u21D2 seam.permission_denied",
+    disposition: "enforced",
+    open: "Access each declared host getter with the grant withheld.",
+    brokenIf: "it returns/throws anything other than a typed SeamPermissionDenied.",
+    run({ subjects, host }) {
+      const notes = [];
+      for (const s of subjects) {
+        const ctx = ctxFor(s.principal, "k-brain");
+        for (const perm of declaredHostPermissions(s.definition)) {
+          const getter = Object.keys(GETTER_PERMISSION).find(
+            (k) => GETTER_PERMISSION[k] === perm
+          );
+          if (!getter) continue;
+          const port = host.inject(ctx, NO_GRANTS);
+          try {
+            void port[getter];
+            notes.push(`${s.name}: accessing .${getter} without a grant did NOT throw`);
+          } catch (err) {
+            if (!(err instanceof SeamPermissionDenied) || err.permission !== perm) {
+              notes.push(`${s.name}: .${getter} threw ${String(err)} instead of SeamPermissionDenied(${perm})`);
+            }
+          }
+        }
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C6",
+    title: "typed blocked cause \u2014 a withheld port carries a BlockedReason discriminant",
+    disposition: "enforced",
+    open: "Model an inactive activation result and read its blocked cause.",
+    brokenIf: "the cause is a bare 'blocked' string rather than a typed discriminant.",
+    run() {
+      const notes = [];
+      const withheld = [
+        { ok: false, blocked: { cause: "inactive", scope: "agent" } },
+        { ok: false, blocked: { cause: "missing-host-capability", missing: ["host.notifications"] } },
+        { ok: false, blocked: { cause: "denied-permission", denied: ["brain.read"] } },
+        { ok: false, blocked: { cause: "unmet-requirement", requirement: "connector-auth" } }
+      ];
+      const validCauses = /* @__PURE__ */ new Set(["inactive", "missing-host-capability", "denied-permission", "unmet-requirement"]);
+      for (const r of withheld) {
+        if (r.ok) {
+          notes.push("expected a withheld result");
+          continue;
+        }
+        const cause = r.blocked.cause;
+        if (typeof cause !== "string" || cause === "blocked" || !validCauses.has(cause)) {
+          notes.push(`blocked cause "${String(cause)}" is not a typed discriminant`);
+        }
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C7",
+    title: "typed contributionId \u2014 built from { ext, name? }, not a raw string",
+    disposition: "enforced",
+    open: "Build every contribution through the define* builders and watch the deprecation registry.",
+    brokenIf: "a contributionId took the raw-string path (recorded by the deprecation bridge).",
+    run({ subjects, negatives }) {
+      const notes = [];
+      const raw = new Set(rawContributionIdUsages());
+      for (const s of subjects) {
+        for (const c of emitExtensionContributionSet(s.definition).contributions) {
+          if (raw.has(c.contributionId)) notes.push(`${s.name}: "${c.contributionId}" took the deprecated raw-string path`);
+          try {
+            const key = parseContributionId(c.contributionId);
+            if (key.owner !== "ext") notes.push(`${s.name}: "${c.contributionId}" is not an ext-owned id`);
+          } catch (err) {
+            notes.push(`${s.name}: "${c.contributionId}" is unparseable \u2014 ${String(err)}`);
+          }
+        }
+      }
+      for (const s of negatives) {
+        const ids = emitExtensionContributionSet(s.definition).contributions.map((c) => c.contributionId);
+        if (!ids.some((id) => raw.has(id))) notes.push(`negative ${s.name}: expected a raw-string contributionId, none recorded`);
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C8",
+    title: "single-purpose kind \u2014 rendering kinds implement no answering port",
+    disposition: "enforced",
+    open: "Match each contribution kind against whether it provides an answering port.",
+    brokenIf: "a surface/settingsPanel also answers ops, or an answering kind provides no port.",
+    run({ subjects, negatives, host }) {
+      const notes = [];
+      const RENDERING = /* @__PURE__ */ new Set(["surface", "settingsPanel"]);
+      const ANSWERING = /* @__PURE__ */ new Set(["dataEndpoint", "composerCapability", "contextualAction"]);
+      const judge = (s) => {
+        const local = [];
+        const ctx = ctxFor(s.principal, "k-brain");
+        const ports = s.activate(host.inject(ctx, ALL_GRANTS));
+        for (const c of emitExtensionContributionSet(s.definition).contributions) {
+          const hasPort = ports.has(c.contributionId);
+          if (RENDERING.has(c.kind) && hasPort) local.push(`${c.contributionId} (${c.kind}) provides an answering port`);
+          if (ANSWERING.has(c.kind) && !hasPort) local.push(`${c.contributionId} (${c.kind}) provides NO answering port`);
+        }
+        return local;
+      };
+      for (const s of subjects) for (const n of judge(s)) notes.push(`${s.name}: ${n}`);
+      for (const s of negatives) {
+        if (judge(s).length === 0) notes.push(`negative ${s.name}: expected a kind/port mismatch, found none`);
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C9",
+    title: "green against InMemoryHost \u2014 the full happy path runs clean",
+    disposition: "enforced",
+    open: "Activate with correct grants and call every answering port end-to-end.",
+    brokenIf: "any conformant subject throws or returns a malformed response on the happy path.",
+    async run({ subjects, host }) {
+      const notes = [];
+      for (const s of subjects) {
+        const ctx = ctxFor(s.principal, "k-brain");
+        const grants = new Set(s.definition.permissions ?? []);
+        try {
+          const ports = s.activate(host.inject(ctx, grants));
+          for (const [id, ans] of ports) {
+            const out = await exercise(ans, ctx);
+            if (out.response && out.response.ok !== true && out.response.ok !== false) {
+              notes.push(`${s.name}/${id}: response is not a typed SeamResponse`);
+            }
+          }
+        } catch (err) {
+          notes.push(`${s.name}: happy path threw ${String(err)}`);
+        }
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C10",
+    title: "every host route honours activation + gate (incl. the drain side-door)",
+    disposition: "phase5",
+    open: "Drive each op \u2014 including subscription `drain` \u2014 through the production SeamRunner for an INACTIVE principal.",
+    brokenIf: "any route (especially drain) reaches the contribution without a typed denial.",
+    async run({ subjects, wiring }) {
+      const { runner } = wiring;
+      if (!runner) return pending("no production SeamRunner wired (Phase-5 daemon code)");
+      const notes = [];
+      const ops = ["query", "describe", "invoke", "subscribe", "drain"];
+      for (const s of subjects) {
+        const ctx = ctxFor(s.principal, "inactive-agent");
+        const verdict = runner.activate(s.principal.id, ctx);
+        if (verdict.ok) continue;
+        for (const op of ops) {
+          const res = await runner.route(op, { principalId: s.principal.id, contributionId: "data.x" }, void 0, ctx);
+          if (res.ok !== false) notes.push(`${s.name}: route op="${op}" did NOT yield a typed denial for an inactive principal`);
+        }
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C11",
+    title: "exactly one activation authority",
+    disposition: "phase5",
+    open: "Ask the SeamRunner how many independent activation sets exist.",
+    brokenIf: "the count is not exactly 1 (a parallel set like bridge-sessions inactiveExtensions).",
+    run({ wiring }) {
+      const { runner } = wiring;
+      if (!runner) return pending("no production SeamRunner wired (Phase-5 daemon code)");
+      const n = runner.activationAuthorityCount();
+      return n === 1 ? { status: "pass", notes: [] } : { status: "fail", notes: [`activationAuthorityCount()=${n}, expected exactly 1`] };
+    }
+  },
+  {
+    id: "C12",
+    title: "scope is honoured \u2014 per-agent deactivation does not leak to other agents",
+    disposition: "phase5",
+    open: "Deactivate a principal for one agent and check another agent is still active.",
+    brokenIf: "the deactivation blocks other agents, or its scope isn't 'agent'.",
+    run({ subjects, wiring }) {
+      const { runner } = wiring;
+      if (!runner) return pending("no production SeamRunner wired (Phase-5 daemon code)");
+      const notes = [];
+      for (const s of subjects) {
+        const a = runner.activate(s.principal.id, ctxFor(s.principal, "agent-a"));
+        const b = runner.activate(s.principal.id, ctxFor(s.principal, "agent-b"));
+        if (!a.ok) {
+          if (a.blocked.cause === "inactive" && a.blocked.scope !== "agent") {
+            notes.push(`${s.name}: agent-a deactivation scope="${a.blocked.scope}", expected 'agent'`);
+          }
+          if (!b.ok) notes.push(`${s.name}: agent-a deactivation also blocked agent-b (scope leaked)`);
+        }
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C13",
+    title: "builders validate ids \u2014 unknown permission/capability rejected loudly",
+    disposition: "enforced",
+    open: "Pass a bogus permission/capability id to the requires* builders.",
+    brokenIf: "an unknown id passes through silently instead of throwing.",
+    async run() {
+      const notes = [];
+      const { requiresKernelPermissions: requiresKernelPermissions2, requiresHostCapabilities: requiresHostCapabilities2 } = await import("../index.js");
+      const expectThrow = (fn, what) => {
+        try {
+          fn();
+          notes.push(`${what} did not reject an unknown id`);
+        } catch {
+        }
+      };
+      expectThrow(() => requiresKernelPermissions2("not.a.permission"), "requiresKernelPermissions");
+      expectThrow(() => requiresHostCapabilities2("host.not-real"), "requiresHostCapabilities");
+      try {
+        requiresKernelPermissions2("brain.read");
+      } catch (err) {
+        notes.push(`requiresKernelPermissions rejected a KNOWN id: ${String(err)}`);
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C14",
+    title: 'one canonical "none" form for host capabilities',
+    disposition: "enforced",
+    open: "Build the same contribution three ways (omitted / [] / empty requires*) and compare the emitted capabilities.",
+    brokenIf: 'the three "no host capability" forms do not normalize to one canonical value.',
+    run() {
+      const omitted = defineDataEndpoint({ ext: "c14-probe", name: "omitted", displayName: "omitted" });
+      const empty = defineDataEndpoint({ ext: "c14-probe", name: "empty", displayName: "empty", requiredHostCapabilities: [] });
+      const call = defineDataEndpoint({
+        ext: "c14-probe",
+        name: "call",
+        displayName: "call",
+        requiredHostCapabilities: requiresHostCapabilities()
+      });
+      const forms = [omitted, empty, call].map((c) => JSON.stringify(c.requiredHostCapabilities ?? null));
+      const notes = new Set(forms).size === 1 ? [] : [`the three "none" forms normalize differently: ${forms.join(" | ")}`];
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C15",
+    title: "contribution \u2286 extension declarations (kernel permissions)",
+    disposition: "enforced",
+    open: "Validate the references (must pass) and a definition whose contribution requires an undeclared kernel permission (must be flagged). Host capabilities are contribution-scoped (DIV-8), not subset-checked.",
+    brokenIf: "a conformant reference is flagged, or the over-reaching contribution is NOT flagged.",
+    run({ subjects, negatives, wiring }) {
+      const validate = wiring.validateDefinitionCrossRefs ?? validateDefinitionCrossRefs;
+      const notes = [];
+      for (const s of subjects) {
+        const errors = validate(s.definition);
+        if (errors.length) notes.push(`${s.name}: conformant extension flagged \u2014 ${errors.join("; ")}`);
+      }
+      for (const s of negatives) {
+        const errors = validate(s.definition);
+        if (errors.length === 0) notes.push(`negative ${s.name}: over-reaching contribution was NOT flagged`);
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "C16",
+    title: "one gate model per permission domain",
+    disposition: "enforced",
+    open: "Across subjects gating composer.capabilities.invoke, compare WHERE the permission is declared.",
+    brokenIf: "the same domain is gated at the extension level by some and the contribution level by others.",
+    run({ subjects, negatives }) {
+      const DOMAIN = "composer.capabilities.invoke";
+      const styleOf = (s) => {
+        if ((s.definition.permissions ?? []).includes(DOMAIN)) return "extension";
+        const usesAtContribution = emitExtensionContributionSet(s.definition).contributions.some(
+          (c) => (c.requiredKernelPermissions ?? []).includes(DOMAIN)
+        );
+        return usesAtContribution ? "contribution" : "none";
+      };
+      const styles = new Set(subjects.map(styleOf).filter((x) => x !== "none"));
+      const notes = [];
+      if (styles.size > 1) notes.push(`conformant subjects gate ${DOMAIN} inconsistently: ${[...styles].join(" + ")}`);
+      if (negatives.length) {
+        const allStyles = new Set([...subjects, ...negatives].map(styleOf).filter((x) => x !== "none"));
+        if (allStyles.size <= 1) notes.push("negative pair: expected inconsistent gate models across the domain, found uniform");
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "grant-store",
+    title: "grants come from the activation authority, not a hardcoded list",
+    disposition: "phase5",
+    open: "Read a principal's grants from the SeamRunner grant store.",
+    brokenIf: "grants are sourced from a startup constant rather than the per-principal store (DIV-2).",
+    run({ subjects, wiring }) {
+      const { runner } = wiring;
+      if (!runner) return pending("no production SeamRunner / grant store wired (Phase-5 daemon code)");
+      const notes = [];
+      for (const s of subjects) {
+        const grants = runner.grantsFor(s.principal.id, ctxFor(s.principal, "k-brain"));
+        if (!(grants instanceof Set) && typeof grants.has !== "function") {
+          notes.push(`${s.name}: grantsFor did not return a permission set`);
+        }
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  },
+  {
+    id: "agentId-registry",
+    title: "agent id minted only for a registered, host-attested name",
+    disposition: "phase5",
+    open: "Mint an AgentId for a name that is NOT in the agent registry.",
+    brokenIf: "minting succeeds for an unregistered name (today makeAgentId rejects only blanks \u2014 HOST-N3).",
+    run({ wiring }) {
+      const { mintAttestedAgent, agentRegistry } = wiring;
+      if (!mintAttestedAgent || !agentRegistry) return pending("no registry-aware mint wired (Phase-5 host code, HOST-N3)");
+      const notes = [];
+      try {
+        mintAttestedAgent("definitely-not-a-registered-agent", agentRegistry);
+        notes.push("minted an AgentId for an UNREGISTERED name \u2014 registry validation missing");
+      } catch {
+      }
+      const known = [...agentRegistry][0];
+      if (known) {
+        try {
+          mintAttestedAgent(known, agentRegistry);
+        } catch (err) {
+          notes.push(`rejected a REGISTERED name "${known}": ${String(err)}`);
+        }
+      }
+      return { status: notes.length ? "fail" : "pass", notes };
+    }
+  }
+];
+function pending(reason) {
+  return { status: "pending", notes: [reason] };
+}
+var DEFAULT_HOST = () => new InMemoryHost({
+  "k-brain": {
+    entities: [
+      { id: "1", title: "Acme Corp" },
+      { id: "2", title: "Acme Holdings" }
+    ],
+    notes: ["kb-note-1", "kb-note-2", "kb-note-3"]
+  },
+  arcana: {
+    entities: [{ id: "9", title: "Arcana Archive" }],
+    notes: ["arcana-only"]
+  }
+});
+async function runConformance(input) {
+  const host = input.host ?? DEFAULT_HOST();
+  const wiring = input.wiring ?? {};
+  const verdicts = [];
+  for (const check of CHECKS) {
+    const negatives = input.negatives.filter((n) => n.violates === check.id).map((n) => n.subject);
+    let outcome;
+    try {
+      outcome = await check.run({ subjects: input.subjects, negatives, wiring, host });
+    } catch (err) {
+      outcome = { status: "fail", notes: [`check threw: ${String(err)}`] };
+    }
+    verdicts.push({
+      id: check.id,
+      title: check.title,
+      disposition: check.disposition,
+      status: outcome.status,
+      notes: outcome.notes
+    });
+  }
+  const enforcedFailures = verdicts.filter((v) => v.disposition === "enforced" && v.status === "fail").length;
+  const phase5Pending = verdicts.filter((v) => v.disposition === "phase5" && v.status === "pending").length;
+  const phase5Regressions = verdicts.filter((v) => v.disposition === "phase5" && v.status === "fail").length;
+  const negativeGaps = 0;
+  return {
+    verdicts,
+    enforcedFailures,
+    phase5Pending,
+    phase5Regressions,
+    negativeGaps,
+    ok: enforcedFailures === 0 && phase5Regressions === 0
+  };
+}
+var ICON = { pass: "\u{1F7E2}", fail: "\u{1F534}", pending: "\u{1F7E1}" };
+function renderReport(report, opts) {
+  const lines = [];
+  lines.push("");
+  lines.push("  C1\u2013C16 EXTENSION SDK CONFORMANCE  (docs/65 \xA75)");
+  lines.push("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const v of report.verdicts) {
+    const tag = v.disposition === "phase5" ? " [phase5]" : "";
+    lines.push(`  ${ICON[v.status]} ${v.id.padEnd(16)} ${v.title}${tag}`);
+    for (const n of v.notes) lines.push(`        \u21B3 ${n}`);
+  }
+  lines.push("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  lines.push(
+    `  enforced failures: ${report.enforcedFailures}   phase5 pending: ${report.phase5Pending}   phase5 regressions: ${report.phase5Regressions}`
+  );
+  const strictFail = (opts?.strict ?? false) && report.phase5Pending > 0;
+  if (report.ok && !strictFail) {
+    lines.push("  RESULT: GREEN \u2014 every enforced requirement holds (\u{1F7E1} rows are Phase-5 targets).");
+  } else {
+    lines.push("  RESULT: RED \u2014 see \u{1F534} rows above.");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/testing/conformance-subjects.ts
+clearRawContributionIdUsages();
+var principal = (id) => ({ kind: "plugin", id, attestedBy: "session" });
+var strArg = (v) => typeof v === "string" ? v : "";
+var seamProbe = {
+  name: "seam-probe",
+  principal: principal("plugin.seam-probe"),
+  definition: defineExtension({
+    pluginId: "plugin.seam-probe",
+    displayName: "Seam Probe",
+    permissions: requiresKernelPermissions("brain.read", "host.context.read", "host.command.invoke"),
+    surfaces: [
+      defineSurface({
+        ext: "seam-probe",
+        displayName: "Seam Probe",
+        requiredHostCapabilities: [],
+        mount: "web/seam-probe",
+        hostSlots: ["workspace.surface"]
+      })
+    ],
+    dataEndpoints: [defineDataEndpoint({ ext: "seam-probe", name: "brain", displayName: "Seam Probe brain" })],
+    composerCapabilities: [
+      defineComposerCapability({ ext: "seam-probe", displayName: "Seam Probe composer", requiredHostCapabilities: [] })
+    ]
+  }),
+  activate(host) {
+    const map = /* @__PURE__ */ new Map();
+    map.set("data.seam-probe.brain", {
+      async query(payload, ctx) {
+        const hits = await host.brain.query(strArg(payload.filter?.q), { limit: payload.limit });
+        return hits.map((h) => ({ id: h.id, title: h.title, principalId: ctx.principal.id }));
+      }
+    });
+    map.set("composer.seam-probe", {
+      async describe() {
+        return { commands: [{ commandId: "seam-probe.ping", displayName: "Ping host" }] };
+      },
+      async invoke(payload, ctx) {
+        const snapshot = await host.context.snapshot();
+        const command = await host.command.invoke(payload.commandId, payload.args);
+        return { ok: true, data: { activeAgent: snapshot.activeAgent, principalId: ctx.principal.id, command } };
+      }
+    });
+    return map;
+  },
+  identityProbe: (ctx) => ctx.principal.id
+};
+var notesLens = {
+  name: "notes-lens",
+  principal: principal("plugin.notes-lens"),
+  definition: defineExtension({
+    pluginId: "plugin.notes-lens",
+    displayName: "Notes Lens",
+    permissions: requiresKernelPermissions("brain.read"),
+    surfaces: [
+      defineSurface({
+        ext: "notes-lens",
+        displayName: "Notes Lens",
+        requiredHostCapabilities: [],
+        mount: "web/notes-lens",
+        hostSlots: ["workspace.surface"]
+      })
+    ],
+    dataEndpoints: [defineDataEndpoint({ ext: "notes-lens", name: "recent", displayName: "Notes Lens recent" })],
+    contextualActions: [
+      defineContextualAction({
+        ext: "notes-lens",
+        name: "summarize",
+        displayName: "Summarize notes",
+        requiredHostCapabilities: []
+      })
+    ]
+  }),
+  activate(host) {
+    const map = /* @__PURE__ */ new Map();
+    map.set("data.notes-lens.recent", {
+      async query(payload, ctx) {
+        const hits = await host.brain.query(strArg(payload.filter?.q), { limit: payload.limit });
+        const stats = await host.brain.stats();
+        return [{ noteCount: stats.notes, top: hits[0]?.title ?? null, principalId: ctx.principal.id }];
+      }
+    });
+    map.set("contextualAction.notes-lens.summarize", {
+      async invoke(payload, ctx) {
+        const hits = await host.brain.query(strArg(payload.args?.q), {});
+        return { ok: true, data: { summary: hits.map((h) => h.title).join(", "), principalId: ctx.principal.id } };
+      }
+    });
+    return map;
+  },
+  identityProbe: (ctx) => ctx.principal.id
+};
+var REFERENCE_EXTENSIONS = [seamProbe, notesLens];
+var emptyActivate = () => /* @__PURE__ */ new Map();
+var globalReach = {
+  name: "global-reach",
+  principal: principal("plugin.global-reach"),
+  definition: defineExtension({
+    pluginId: "plugin.global-reach",
+    displayName: "Global Reach",
+    permissions: requiresKernelPermissions("brain.read"),
+    dataEndpoints: [defineDataEndpoint({ ext: "global-reach", name: "brain", displayName: "GR brain" })]
+  }),
+  activate() {
+    const map = /* @__PURE__ */ new Map();
+    map.set("data.global-reach.brain", {
+      async query(_payload, ctx) {
+        return [{ id: "leak", title: "Leaked Global Row", principalId: ctx.principal.id }];
+      }
+    });
+    return map;
+  },
+  identityProbe: (ctx) => ctx.principal.id
+};
+var agentBlind = {
+  name: "agent-blind",
+  principal: principal("plugin.agent-blind"),
+  definition: defineExtension({
+    pluginId: "plugin.agent-blind",
+    displayName: "Agent Blind",
+    permissions: requiresKernelPermissions("brain.read"),
+    dataEndpoints: [defineDataEndpoint({ ext: "agent-blind", name: "brain", displayName: "AB brain" })]
+  }),
+  activate() {
+    const map = /* @__PURE__ */ new Map();
+    map.set("data.agent-blind.brain", {
+      async query(_payload, ctx) {
+        return [{ id: "const", title: "CONSTANT", principalId: ctx.principal.id }];
+      }
+    });
+    return map;
+  },
+  identityProbe: (ctx) => ctx.principal.id
+};
+var underDeclared = {
+  name: "under-declared",
+  principal: principal("plugin.under-declared"),
+  definition: defineExtension({
+    pluginId: "plugin.under-declared",
+    displayName: "Under Declared",
+    permissions: [],
+    dataEndpoints: [defineDataEndpoint({ ext: "under-declared", name: "brain", displayName: "UD brain" })]
+  }),
+  activate(host) {
+    const map = /* @__PURE__ */ new Map();
+    map.set("data.under-declared.brain", {
+      async query(_payload, ctx) {
+        const hits = await host.brain.query("", {});
+        return hits.map((h) => ({ title: h.title, principalId: ctx.principal.id }));
+      }
+    });
+    return map;
+  },
+  identityProbe: (ctx) => ctx.principal.id
+};
+var overDeclared = {
+  name: "over-declared",
+  principal: principal("plugin.over-declared"),
+  definition: defineExtension({
+    pluginId: "plugin.over-declared",
+    displayName: "Over Declared",
+    permissions: requiresKernelPermissions("brain.read", "host.command.invoke"),
+    dataEndpoints: [defineDataEndpoint({ ext: "over-declared", name: "brain", displayName: "OD brain" })]
+  }),
+  activate(host) {
+    const map = /* @__PURE__ */ new Map();
+    map.set("data.over-declared.brain", {
+      async query(_payload, ctx) {
+        const hits = await host.brain.query("", {});
+        return hits.map((h) => ({ title: h.title, principalId: ctx.principal.id }));
+      }
+    });
+    return map;
+  },
+  identityProbe: (ctx) => ctx.principal.id
+};
+var payloadIdentity = {
+  name: "payload-identity",
+  principal: principal("plugin.payload-identity"),
+  definition: defineExtension({
+    pluginId: "plugin.payload-identity",
+    displayName: "Payload Identity",
+    dataEndpoints: [defineDataEndpoint({ ext: "payload-identity", name: "rows", displayName: "PI rows" })]
+  }),
+  activate: emptyActivate,
+  identityProbe: (_ctx, forgedExtensionId) => forgedExtensionId
+};
+var rawId = {
+  name: "raw-id",
+  principal: principal("plugin.raw-id"),
+  definition: defineExtension({
+    pluginId: "plugin.raw-id",
+    displayName: "Raw Id",
+    surfaces: [defineSurface({ contributionId: "surface.raw-id-thing", displayName: "Raw", requiredHostCapabilities: [] })]
+  }),
+  activate: emptyActivate,
+  identityProbe: (ctx) => ctx.principal.id
+};
+var dualKind = {
+  name: "dual-kind",
+  principal: principal("plugin.dual-kind"),
+  definition: defineExtension({
+    pluginId: "plugin.dual-kind",
+    displayName: "Dual Kind",
+    surfaces: [
+      defineSurface({ ext: "dual-kind", displayName: "Dual", requiredHostCapabilities: [], mount: "web/dual" })
+    ]
+  }),
+  activate() {
+    const map = /* @__PURE__ */ new Map();
+    map.set("surface.dual-kind", {
+      async query() {
+        return [];
+      }
+    });
+    return map;
+  },
+  identityProbe: (ctx) => ctx.principal.id
+};
+var overReachContribution = {
+  name: "over-reach-contribution",
+  principal: principal("plugin.over-reach"),
+  definition: defineExtension({
+    pluginId: "plugin.over-reach",
+    displayName: "Over Reach",
+    permissions: [],
+    // extension-level: declares NO kernel permissions
+    dataEndpoints: [
+      defineDataEndpoint({
+        ext: "over-reach",
+        name: "brain",
+        displayName: "OR brain",
+        requiredKernelPermissions: ["brain.read"]
+        // contribution-level: reaches for one ungranted
+      })
+    ]
+  }),
+  activate: emptyActivate,
+  identityProbe: (ctx) => ctx.principal.id
+};
+var composerExtensionGated = {
+  name: "composer-extension-gated",
+  principal: principal("plugin.composer-ext-gated"),
+  definition: defineExtension({
+    pluginId: "plugin.composer-ext-gated",
+    displayName: "Composer Extension Gated",
+    permissions: requiresKernelPermissions("composer.capabilities.invoke"),
+    composerCapabilities: [
+      defineComposerCapability({ ext: "ext-gated", displayName: "Ext gated", requiredHostCapabilities: [] })
+    ]
+  }),
+  activate: emptyActivate,
+  identityProbe: (ctx) => ctx.principal.id
+};
+var composerContributionGated = {
+  name: "composer-contribution-gated",
+  principal: principal("plugin.composer-contrib-gated"),
+  definition: defineExtension({
+    pluginId: "plugin.composer-contrib-gated",
+    displayName: "Composer Contribution Gated",
+    composerCapabilities: [
+      defineComposerCapability({
+        ext: "contrib-gated",
+        displayName: "Contrib gated",
+        requiredHostCapabilities: [],
+        requiredKernelPermissions: ["composer.capabilities.invoke"]
+        // gated at the WRONG level vs the pair
+      })
+    ]
+  }),
+  activate: emptyActivate,
+  identityProbe: (ctx) => ctx.principal.id
+};
+var NEGATIVE_FIXTURES = [
+  { violates: "C1", subject: globalReach },
+  { violates: "C2", subject: agentBlind },
+  { violates: "C3", subject: underDeclared },
+  { violates: "C3", subject: overDeclared },
+  { violates: "C4", subject: payloadIdentity },
+  { violates: "C7", subject: rawId },
+  { violates: "C8", subject: dualKind },
+  { violates: "C15", subject: overReachContribution },
+  { violates: "C16", subject: composerExtensionGated },
+  { violates: "C16", subject: composerContributionGated }
+];
+export {
+  InMemoryBrainProvider,
+  InMemoryHost,
+  NEGATIVE_FIXTURES,
+  REFERENCE_EXTENSIONS,
+  renderReport,
+  runConformance
+};
+//# sourceMappingURL=index.js.map