stylegallery 0.1.0 → 0.1.1

package/scripts/test-agent-adapter-conformance.mjs

@@ -1,250 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Cross-surface conformance test.
- *
- * A CLI JSON-RPC-ish envelope and an MCP envelope are transport projections;
- * this harness removes only those envelopes and compares the canonical domain
- * payload (or the stable failure codes).  It therefore catches an adapter
- * that returns a plausible wrapper while silently changing domain semantics.
- */
-
-import { spawnSync } from "node:child_process";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const cliPath = path.join(repositoryRoot, "scripts", "sg.mjs");
-const profileRef = "sg:profile/editorial-reference-profile";
-
-function stable(value) {
-  if (Array.isArray(value)) return value.map(stable);
-  if (value && typeof value === "object") {
-    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])]));
-  }
-  return value;
-}
-
-function equal(left, right) {
-  return JSON.stringify(stable(left)) === JSON.stringify(stable(right));
-}
-
-function parseJson(text) {
-  if (typeof text !== "string" || text.length === 0) return null;
-  try { return JSON.parse(text); } catch { return null; }
-}
-
-function codes(envelope) {
-  return Array.isArray(envelope?.failures)
-    ? envelope.failures.map((failure) => failure?.code).filter((code) => typeof code === "string").sort()
-    : [];
-}
-
-function unwrap(value, operation) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  if (typeof value.ok === "boolean") {
-    if (value.ok === true) return { ok: true, operation: value.operation ?? operation, result: value.result ?? null };
-    return { ok: false, operation: value.operation ?? operation, failures: codes(value) };
-  }
-  if (value.result && typeof value.result === "object" && typeof value.result.ok === "boolean") {
-    return unwrap(value.result, operation);
-  }
-  return null;
-}
-
-function cliInvocation(args) {
-  const child = spawnSync(process.execPath, [cliPath, ...args, "--format", "json"], {
-    cwd: repositoryRoot,
-    encoding: "utf8",
-  });
-  const parsed = parseJson(child.stdout);
-  return {
-    child,
-    envelope: unwrap(parsed, args[0]),
-    parsed,
-  };
-}
-
-function mcpEnvelope(response, operation) {
-  const structured = response?.structuredContent;
-  const text = response?.content?.find((item) => item?.type === "text")?.text;
-  const parsed = structured && typeof structured === "object" ? structured : parseJson(text);
-  return unwrap(parsed, operation);
-}
-
-function result(name, expected, actual, ok) {
-  return { actual, expected, name, ok };
-}
-
-function compare(name, cliRun, mcpRun) {
-  const cliEnvelope = cliRun.envelope;
-  const mcpEnvelopeValue = mcpRun.envelope;
-  if (!cliEnvelope || !mcpEnvelopeValue) {
-    return result(
-      name,
-      "both adapters produce a parseable {ok,operation,result|failures} envelope",
-      {
-        cli: { status: cliRun.child.status, stderr: cliRun.child.stderr, envelope: cliEnvelope, stdout: cliRun.child.stdout },
-        mcp: { response: mcpRun.response, envelope: mcpEnvelopeValue },
-      },
-      false,
-    );
-  }
-  if (cliEnvelope.ok !== mcpEnvelopeValue.ok) {
-    return result(
-      name,
-      "CLI and MCP agree on success versus failure",
-      { cli: cliEnvelope, mcp: mcpEnvelopeValue },
-      false,
-    );
-  }
-  if (cliEnvelope.ok === false) {
-    const cliCodes = cliEnvelope.failures;
-    const mcpCodes = mcpEnvelopeValue.failures;
-    return result(
-      name,
-      "CLI and MCP expose identical stable error codes",
-      { cliCodes, mcpCodes, cliStatus: cliRun.child.status, mcpResponse: mcpRun.response },
-      cliRun.child.status !== 0 && cliRun.child.stderr.length === 0 && equal(cliCodes, mcpCodes),
-    );
-  }
-  return result(
-    name,
-    "CLI and MCP expose identical operation and canonical domain result",
-    { cli: cliEnvelope, mcp: mcpEnvelopeValue },
-    cliRun.child.status === 0
-      && cliRun.child.stderr.length === 0
-      && cliEnvelope.operation === mcpEnvelopeValue.operation
-      && equal(cliEnvelope.result, mcpEnvelopeValue.result),
-  );
-}
-
-async function loadSdk(results) {
-  try {
-    const sdk = {
-      ...(await import("@modelcontextprotocol/sdk/server/mcp.js")),
-      ...(await import("@modelcontextprotocol/sdk/client/index.js")),
-      ...(await import("@modelcontextprotocol/sdk/inMemory.js")),
-    };
-    const available = typeof sdk.McpServer === "function"
-      && typeof sdk.Client === "function"
-      && typeof sdk.InMemoryTransport?.createLinkedPair === "function";
-    results.push(result(
-      "conformance_sdk_available",
-      "official stable MCP SDK is available",
-      { available },
-      available,
-    ));
-    return available ? sdk : null;
-  } catch (error) {
-    results.push(result(
-      "conformance_sdk_available",
-      "official stable MCP SDK is available",
-      { code: "mcp_sdk_unavailable", error: error instanceof Error ? error.message : String(error) },
-      false,
-    ));
-    return null;
-  }
-}
-
-async function loadAdapter(results) {
-  try {
-    const adapter = await import("./agent-native/mcp-adapter.mjs");
-    const factory = adapter.createStyleGalleryMcpServer ?? adapter.createMcpServer;
-    results.push(result(
-      "conformance_adapter_available",
-      "mcp-adapter exports createStyleGalleryMcpServer",
-      { exports: Object.keys(adapter).sort() },
-      typeof factory === "function",
-    ));
-    return factory;
-  } catch (error) {
-    results.push(result(
-      "conformance_adapter_available",
-      "mcp-adapter exports createStyleGalleryMcpServer",
-      { code: "mcp_adapter_unavailable", error: error instanceof Error ? error.message : String(error) },
-      false,
-    ));
-    return null;
-  }
-}
-
-async function main() {
-  const results = [];
-  const sdk = await loadSdk(results);
-  const createServer = await loadAdapter(results);
-  if (!sdk || !createServer) {
-    const report = { ok: false, results };
-    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-    process.exitCode = 1;
-    return;
-  }
-
-  const server = await createServer();
-  const [clientTransport, serverTransport] = sdk.InMemoryTransport.createLinkedPair();
-  const client = new sdk.Client({ name: "stylegallery-adapter-conformance", version: "1.0.0" });
-  try {
-    await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
-    const cases = [
-      { name: "discover", cli: ["discover"], mcp: { name: "discover", arguments: {} } },
-      { name: "ops", cli: ["ops"], mcp: { name: "ops", arguments: {} } },
-      { name: "resolve", cli: ["resolve", profileRef], mcp: { name: "resolve", arguments: { stable_ref: profileRef } } },
-      { name: "claims", cli: ["claims", profileRef], mcp: { name: "claims", arguments: { stable_ref: profileRef } } },
-      { name: "context", cli: ["context", profileRef], mcp: { name: "context", arguments: { stable_ref: profileRef } } },
-      { name: "resolve_malformed", cli: ["resolve", "not-a-stable-ref"], mcp: { name: "resolve", arguments: { stable_ref: "not-a-stable-ref" } } },
-    ];
-    for (const testCase of cases) {
-      const cliRun = cliInvocation(testCase.cli);
-      let response;
-      let mcpError = null;
-      try {
-        response = await client.callTool(testCase.mcp);
-      } catch (error) {
-        mcpError = error;
-      }
-      const mcpRun = {
-        envelope: mcpError ? null : mcpEnvelope(response, testCase.name.split("_")[0]),
-        response: mcpError ? { error: mcpError instanceof Error ? mcpError.message : String(mcpError) } : response,
-      };
-      if (mcpError && cliRun.envelope?.ok === false) {
-        results.push(result(
-          `adapter_equivalence_${testCase.name}`,
-          "both adapters preserve the same stable failure code",
-          { cli: cliRun.envelope, mcpError: mcpRun.response },
-          false,
-        ));
-      } else {
-        results.push(compare(`adapter_equivalence_${testCase.name}`, cliRun, mcpRun));
-      }
-    }
-  } catch (error) {
-    results.push(result(
-      "adapter_conformance_round_trip",
-      "CLI and MCP conformance fixture executes over an initialized in-memory transport",
-      { code: "conformance_round_trip_failed", error: error instanceof Error ? error.message : String(error) },
-      false,
-    ));
-  } finally {
-    await client.close().catch(() => {});
-    const closed = server.close?.();
-    if (closed && typeof closed.catch === "function") await closed.catch(() => {});
-  }
-
-  const report = { ok: results.every((item) => item.ok), results };
-  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-  process.exitCode = report.ok ? 0 : 1;
-}
-
-await main().catch((error) => {
-  const report = {
-    ok: false,
-    results: [result(
-      "conformance_harness_runtime",
-      "harness emits structured JSON instead of crashing",
-      { code: "conformance_harness_runtime", error: error instanceof Error ? error.message : String(error) },
-      false,
-    )],
-  };
-  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-  process.exitCode = 1;
-});

package/scripts/test-agent-conformance-receipt.mjs

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-
-import { spawnSync } from "node:child_process";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { agentNativeFixture } from "./agent-native/fixture.mjs";
-import { createVersionId } from "./agent-native/identity.mjs";
-import { createSelfDescription } from "./agent-native/self-description.mjs";
-
-const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const operations = agentNativeFixture.records.filter((record) => record.record_kind === "operation");
-
-function check(name, expected, actual, ok) {
-  return { actual, expected, name, ok };
-}
-
-function selfDescriptionFor(records) {
-  return createSelfDescription({
-    fixture: {
-      fixture_ref: agentNativeFixture.fixture_ref,
-      manifest: agentNativeFixture.manifest,
-      records,
-    },
-    operations,
-  });
-}
-
-function tamperedRecords(mutator) {
-  const records = structuredClone(agentNativeFixture.records);
-  mutator(records);
-  return records;
-}
-
-function expectedFailure(name, code, mutator) {
-  try {
-    selfDescriptionFor(tamperedRecords(mutator));
-    return check(name, code, { code: "no_failure" }, false);
-  } catch (error) {
-    return check(name, code, { code: error?.code ?? "unknown", message: error?.message }, error?.code === code);
-  }
-}
-
-function runDiscover() {
-  const child = spawnSync(process.execPath, [path.join(repositoryRoot, "scripts", "sg.mjs"), "discover", "--format", "json"], {
-    cwd: repositoryRoot,
-    encoding: "utf8",
-  });
-  let report;
-  try { report = JSON.parse(child.stdout); } catch { report = null; }
-  const claims = report?.result?.conformance?.claims ?? [];
-  const receipt = claims[0]?.execution_receipts?.[0];
-  return check(
-    "discover_exposes_verified_execution_receipt",
-    "discover is successful only with fixture_verified status and a bound PASS receipt",
-    {
-      status: child.status,
-      stderr: child.stderr,
-      conformance_status: report?.result?.conformance?.status,
-      receipt_ref: receipt?.receipt?.stable_ref,
-      fixture_version_id: receipt?.receipt?.fixture_version_id,
-      verifier_status: receipt?.receipt?.verification?.status,
-    },
-    child.status === 0
-      && child.signal === null
-      && child.stderr === ""
-      && report?.ok === true
-      && report?.result?.conformance?.status === "fixture_verified"
-      && receipt?.receipt?.record_kind === "execution_receipt"
-      && receipt?.receipt?.verification?.status === "PASS"
-      && receipt?.receipt?.fixture_version_id === receipt?.source?.version_id,
-  );
-}
-
-const results = [
-  check(
-    "default_fixture_receipt_verifies",
-    "the immutable fixture has one content-bound execution receipt",
-    {
-      status: createSelfDescription({ fixture: agentNativeFixture, operations }).conformance.status,
-      receipts: agentNativeFixture.records.filter((record) => record.record_kind === "execution_receipt").length,
-    },
-    agentNativeFixture.records.filter((record) => record.record_kind === "execution_receipt").length === 1,
-  ),
-  expectedFailure("missing_receipt_cannot_claim_fixture_verified", "self_description_execution_receipt_missing", (records) => {
-    const index = records.findIndex((record) => record.record_kind === "execution_receipt");
-    records.splice(index, 1);
-  }),
-  expectedFailure("wrong_fixture_version_is_rejected", "self_description_receipt_version_mismatch", (records) => {
-    records.find((record) => record.record_kind === "execution_receipt").fixture_version_id = "sg:artifact/sg-cli-conformance-test@sha256:0000000000000000000000000000000000000000000000000000000000000000";
-  }),
-  expectedFailure("tampered_result_digest_is_rejected", "self_description_receipt_result_digest_mismatch", (records) => {
-    records.find((record) => record.record_kind === "execution_receipt").result_sha256 = "sha256:0000000000000000000000000000000000000000000000000000000000000000";
-  }),
-  expectedFailure("unverified_receipt_is_rejected", "self_description_receipt_unverified", (records) => {
-    const receipt = records.find((record) => record.record_kind === "execution_receipt");
-    receipt.verification.status = "PASS_WITH_WARNINGS";
-    const payload = { ...receipt };
-    delete payload.version_id;
-    receipt.version_id = createVersionId({ stableRef: receipt.stable_ref, payload });
-  }),
-  runDiscover(),
-];
-
-const report = { ok: results.every((result) => result.ok), results };
-process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-process.exitCode = report.ok ? 0 : 1;

package/scripts/test-agent-events.mjs

@@ -1,81 +0,0 @@
-#!/usr/bin/env node
-
-import { appendEvent, eventHeads } from "./agent-native/events.mjs";
-
-const cases = [];
-
-function test(name, scenario) {
-  try {
-    scenario();
-    cases.push({ name, ok: true });
-  } catch (error) {
-    cases.push({
-      error: error instanceof Error ? error.message : String(error),
-      name,
-      ok: false,
-    });
-  }
-}
-
-function equal(actual, expected, label) {
-  if (actual !== expected) throw new Error(`${label}: expected ${expected}, received ${actual}`);
-}
-
-function rejectsCycle(events, event) {
-  try {
-    appendEvent({ event, events });
-  } catch (error) {
-    if (error instanceof TypeError && error.message.includes("cycle")) return;
-    throw error;
-  }
-  throw new Error("expected appendEvent to reject a causal cycle");
-}
-
-test("append_rejects_two_node_cycle_completed_by_new_event", () => {
-  // Given A references a parent B that is not present yet.
-  const events = [{ event_id: "sg:event/a", parents: ["sg:event/b"], type: "a" }];
-  // When B is appended with A as its parent.
-  // Then combined-graph validation rejects the newly completed cycle.
-  rejectsCycle(events, { event_id: "sg:event/b", parents: ["sg:event/a"], type: "b" });
-});
-
-test("append_rejects_long_cycle_completed_by_new_event", () => {
-  // Given A -> B -> C with C unresolved.
-  const events = [
-    { event_id: "sg:event/a", parents: ["sg:event/b"], type: "a" },
-    { event_id: "sg:event/b", parents: ["sg:event/c"], type: "b" },
-  ];
-  // When C is appended pointing back to A.
-  // Then combined-graph validation rejects the three-node cycle.
-  rejectsCycle(events, { event_id: "sg:event/c", parents: ["sg:event/a"], type: "c" });
-});
-
-test("append_allows_unresolved_parent_to_close_acyclically", () => {
-  // Given a child references a future parent.
-  const events = [{ event_id: "sg:event/child", parents: ["sg:event/parent"], type: "child" }];
-  // When the future parent is appended as a root.
-  const combined = appendEvent({
-    event: { event_id: "sg:event/parent", parents: [], type: "parent" },
-    events,
-  });
-  // Then both immutable events remain and the child is the sole head.
-  equal(combined.length, 2, "event count");
-  equal(eventHeads({ events: combined }).join(","), "sg:event/child", "heads");
-});
-
-test("append_of_identical_event_is_idempotent", () => {
-  // Given one immutable event already exists.
-  const event = { event_id: "sg:event/root", parents: [], type: "root" };
-  // When the same canonical event is appended again.
-  const combined = appendEvent({ event, events: [event] });
-  // Then no duplicate is created.
-  equal(combined.length, 1, "event count");
-});
-
-const report = {
-  contract: "agent-native-causal-events",
-  ok: cases.every((item) => item.ok),
-  results: cases,
-};
-process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-process.exitCode = report.ok ? 0 : 1;

package/scripts/test-agent-execution-effects.mjs

@@ -1,114 +0,0 @@
-import {
-  callExport,
-  failFromCall,
-  hasAnyText,
-  isObject,
-  payload,
-  pick,
-  result,
-} from "./test-agent-execution-fixtures.mjs";
-
-export async function exerciseExecutionEffects(modules, state) {
-  const rows = [];
-  const effectCall = await callExport(modules.execution, "execution", "recordEffectAttempt", {
-    attempt: "external-call",
-    connector: "fixture-connector",
-    connectorReceipt: null,
-    effect: "sg:effect/execution-fixture",
-    effectClass: "EXTERNAL",
-    effectId: "sg:effect/execution-fixture",
-    idempotencyKey: "idem:execution-fixture",
-    operation: state.operation,
-    run: state.run,
-    state: "UNCERTAIN",
-    task: state.task,
-  });
-  const uncertain = effectCall.ok ? payload(effectCall.value) : null;
-  rows.push(effectCall.ok
-    ? result(
-      "external_effect_without_receipt_is_uncertain",
-      "an external attempt without durable connector receipt is UNCERTAIN",
-      uncertain,
-      isObject(uncertain) && hasAnyText(uncertain, ["state", "status", "effectState", "effect_state"], ["UNCERTAIN", "uncertain"]),
-    )
-    : failFromCall("external_effect_without_receipt_is_uncertain", "an external attempt without durable connector receipt is UNCERTAIN", effectCall));
-
-  const recoveredCall = await callExport(modules.execution, "execution", "reconcileEffect", {
-    effect: uncertain,
-    observation: { connectorReceipt: "sg:connector-receipt/recovered", status: "COMMITTED" },
-    observations: [{ connectorReceipt: "sg:connector-receipt/recovered", status: "COMMITTED" }],
-    strategy: "reconcile",
-  });
-  const recovered = recoveredCall.ok ? payload(recoveredCall.value) : null;
-  rows.push(recoveredCall.ok
-    ? result(
-      "uncertain_effect_reconciles_from_positive_observation",
-      "positive connector observation yields COMMITTED and preserves receipt",
-      recovered,
-      isObject(recovered)
-        && hasAnyText(recovered, ["state", "status", "effectState", "effect_state"], ["COMMITTED", "committed"])
-        && typeof pick(recovered, ["connectorReceipt", "connector_receipt", "receiptId", "receipt_id"]) === "string",
-    )
-    : failFromCall("uncertain_effect_reconciles_from_positive_observation", "positive connector observation yields COMMITTED and preserves receipt", recoveredCall));
-
-  const compensatedCall = await callExport(modules.execution, "execution", "reconcileEffect", {
-    effect: uncertain,
-    observation: { status: "ABSENT" },
-    observations: [{ status: "ABSENT" }],
-    strategy: "compensate",
-  });
-  const compensated = compensatedCall.ok ? payload(compensatedCall.value) : null;
-  rows.push(compensatedCall.ok
-    ? result(
-      "uncertain_effect_can_be_compensated",
-      "negative connector observation with explicit compensation yields COMPENSATED",
-      compensated,
-      isObject(compensated) && hasAnyText(compensated, ["state", "status", "effectState", "effect_state"], ["COMPENSATED", "compensated"]),
-    )
-    : failFromCall("uncertain_effect_can_be_compensated", "negative connector observation with explicit compensation yields COMPENSATED", compensatedCall));
-
-  const conflictCall = await callExport(modules.execution, "execution", "reconcileEffect", {
-    effect: uncertain,
-    observation: { status: "COMMITTED" },
-    observations: [{ status: "COMMITTED" }, { status: "ABSENT" }],
-    strategy: "reconcile",
-  });
-  const conflict = conflictCall.ok ? payload(conflictCall.value) : null;
-  rows.push(conflictCall.ok
-    ? result(
-      "conflicting_reconciliation_stays_uncertain",
-      "conflicting observations never silently commit or compensate",
-      conflict,
-      isObject(conflict) && hasAnyText(conflict, ["state", "status", "effectState", "effect_state"], ["UNCERTAIN", "uncertain"]),
-    )
-    : failFromCall("conflicting_reconciliation_stays_uncertain", "conflicting observations never silently commit or compensate", conflictCall));
-
-  const receiptCall = await callExport(modules.execution, "execution", "createReceipt", {
-    causalParents: ["sg:event/effect-reconciled"],
-    effect: recovered,
-    effects: [recovered],
-    input: { stableRef: "sg:profile/editorial-reference-profile" },
-    operation: state.operation,
-    output: { stableRef: "sg:profile/editorial-reference-profile", resolved: true },
-    policyDecision: pick(state.authorized, ["decision", "policyDecision", "policy_decision"]) ?? state.authorized,
-    run: state.run,
-    task: state.task,
-  });
-  const receipt = receiptCall.ok ? payload(receiptCall.value) : null;
-  rows.push(receiptCall.ok
-    ? result(
-      "invocation_receipt_binds_operation_task_run_and_effect",
-      "receipt records operation, task/run IDs, normalized input/output digests, policy, effects, and causal parents",
-      receipt,
-      isObject(receipt)
-        && typeof pick(receipt, ["inputDigest", "input_digest", "normalizedInputDigest", "normalized_input_digest"]) === "string"
-        && typeof pick(receipt, ["outputDigest", "output_digest", "normalizedOutputDigest", "normalized_output_digest"]) === "string"
-        && typeof pick(receipt, ["taskId", "task_id"]) === "string"
-        && typeof pick(receipt, ["runId", "run_id"]) === "string"
-        && Array.isArray(pick(receipt, ["effects", "effectIds", "effect_ids"]))
-        && Array.isArray(pick(receipt, ["causalParents", "causal_parents", "parents"])),
-    )
-    : failFromCall("invocation_receipt_binds_operation_task_run_and_effect", "receipt records operation, task/run IDs, normalized input/output digests, policy, effects, and causal parents", receiptCall));
-
-  return { rows, uncertain, recovered, receipt };
-}

package/scripts/test-agent-execution-fixtures.mjs

@@ -1,140 +0,0 @@
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-export const modulePaths = {
-  execution: path.join(repositoryRoot, "scripts", "agent-native", "execution.mjs"),
-  events: path.join(repositoryRoot, "scripts", "agent-native", "events.mjs"),
-  retrieval: path.join(repositoryRoot, "scripts", "agent-native", "retrieval.mjs"),
-  learning: path.join(repositoryRoot, "scripts", "agent-native", "learning.mjs"),
-};
-
-export const fixedNow = "2026-01-02T03:04:05.000Z";
-export const fixedExpiry = "2030-01-01T00:00:00.000Z";
-
-function sorted(value) {
-  if (Array.isArray(value)) return value.map(sorted);
-  if (!value || typeof value !== "object") return value;
-  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sorted(value[key])]));
-}
-
-export function bytes(value) {
-  return JSON.stringify(sorted(value));
-}
-
-export function pick(value, keys) {
-  if (!value || typeof value !== "object") return undefined;
-  for (const key of keys) {
-    if (Object.prototype.hasOwnProperty.call(value, key) && value[key] !== undefined) return value[key];
-  }
-  return undefined;
-}
-
-export function hasText(value, keys, expected) {
-  const actual = pick(value, keys);
-  return typeof actual === "string" && actual === expected;
-}
-
-export function hasAnyText(value, keys, expectedValues) {
-  const actual = pick(value, keys);
-  return expectedValues.includes(actual);
-}
-
-export function isObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-export function payload(value) {
-  if (isObject(value) && value.ok === true && Object.prototype.hasOwnProperty.call(value, "result")) {
-    return value.result;
-  }
-  return value;
-}
-
-export async function loadKernelModule(name) {
-  try {
-    const module = await import(pathToFileURL(modulePaths[name]).href);
-    return { ok: true, module };
-  } catch (error) {
-    return {
-      ok: false,
-      error: {
-        code: "kernel_unavailable",
-        module: name,
-        message: error instanceof Error ? error.message : String(error),
-      },
-    };
-  }
-}
-
-export async function callExport(loaded, moduleName, exportName, input) {
-  if (!loaded?.ok) return { ok: false, error: loaded?.error ?? { code: "kernel_unavailable", module: moduleName } };
-  const fn = loaded.module?.[exportName];
-  if (typeof fn !== "function") {
-    return {
-      ok: false,
-      error: { code: "kernel_unavailable", module: moduleName, export: exportName, message: "missing export" },
-    };
-  }
-  try {
-    return { ok: true, value: await fn(input) };
-  } catch (error) {
-    return {
-      ok: false,
-      error: { code: "contract_error", module: moduleName, export: exportName, message: error instanceof Error ? error.message : String(error) },
-    };
-  }
-}
-
-export function result(name, expected, actual, ok, details = undefined) {
-  const record = { actual, expected, name, ok };
-  if (details !== undefined) record.details = details;
-  return record;
-}
-
-export function failFromCall(name, expected, call) {
-  return result(name, expected, call.error, false);
-}
-
-export function idOf(value, fallback = undefined) {
-  return pick(value, ["versionId", "version_id", "stableRef", "stable_ref", "taskId", "task_id", "runId", "run_id", "effectId", "effect_id", "id"]) ?? fallback;
-}
-
-export function stateOf(value) {
-  return pick(value, ["state", "status", "effectState", "effect_state", "disposition"]);
-}
-
-export function operationInput() {
-  return {
-    adapters: ["cli", "mcp"],
-    effect: "NONE",
-    effectClass: "NONE",
-    idempotent: true,
-    inputSchema: {
-      additionalProperties: false,
-      properties: { stableRef: { type: "string" } },
-      required: ["stableRef"],
-      type: "object",
-    },
-    name: "resolve",
-    operation: "resolve",
-    outputSchema: { type: "object" },
-    requiredCapability: "wiki.read",
-    stableRef: "sg:operation/resolve",
-    version: "v1",
-  };
-}
-
-export function grantInput() {
-  return {
-    capability: "wiki.read",
-    expiresAt: fixedExpiry,
-    limits: { calls: 3, maxCalls: 3 },
-    operation: "resolve",
-    operations: ["resolve", "sg:operation/resolve"],
-    resourceScope: ["sg:profile/*", "sg:claim/*"],
-    resources: ["sg:profile/*", "sg:claim/*"],
-    stableRef: "sg:capability/wiki-read",
-    subject: "agent:test",
-  };
-}