stylegallery 0.1.0 → 0.1.2

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

@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-
-import {
-  loadKernelModule,
-  modulePaths,
-  result,
-} from "./test-agent-execution-fixtures.mjs";
-import { exerciseExecutionEffects } from "./test-agent-execution-effects.mjs";
-import { exerciseLearning } from "./test-agent-execution-learning.mjs";
-import { exerciseExecutionLifecycle } from "./test-agent-execution-lifecycle.mjs";
-import { exerciseEvents, exerciseRetrieval } from "./test-agent-execution-views.mjs";
-
-async function main() {
-  const unknownArgs = process.argv.slice(2).filter((arg) => arg !== "--json");
-  if (unknownArgs.length > 0) {
-    const report = { ok: false, results: [result("argument_contract", "only --json is accepted", { unknownArgs }, false)] };
-    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-    process.exitCode = 1;
-    return;
-  }
-
-  const modules = Object.fromEntries(await Promise.all(Object.keys(modulePaths).map(async (name) => [name, await loadKernelModule(name)])));
-  const lifecycle = await exerciseExecutionLifecycle(modules);
-  const effects = await exerciseExecutionEffects(modules, lifecycle);
-  const state = { ...lifecycle, ...effects };
-  const eventRows = await exerciseEvents(modules, state);
-  const retrieval = await exerciseRetrieval(modules);
-  const learningRows = await exerciseLearning(modules, { ...state, ...retrieval });
-  const results = [...lifecycle.rows, ...effects.rows, ...eventRows, ...retrieval.rows, ...learningRows];
-  const report = {
-    contract: "agent-native-execution-kernel",
-    ok: results.length > 0 && results.every((row) => row.ok),
-    results,
-  };
-  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-  process.exitCode = report.ok ? 0 : 1;
-}
-
-await main();

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

@@ -1,130 +0,0 @@
-import {
-  bytes,
-  callExport,
-  failFromCall,
-  fixedNow,
-  hasAnyText,
-  idOf,
-  isObject,
-  payload,
-  pick,
-  result,
-  stateOf,
-} from "./test-agent-execution-fixtures.mjs";
-
-export async function exerciseLearning(modules, state) {
-  const rows = [];
-  const proposalInput = {
-    claim: { stableRef: "sg:claim/retrieval-improvement", text: "The fixture retriever preserves citation coverage." },
-    changes: [{ path: "retriever.strategy", value: "hybrid" }],
-    evidence: [{ receiptId: pick(state.receipt, ["receiptId", "receipt_id", "id"]), stableRef: "sg:evidence/execution-fixture" }],
-    proposer: "agent:proposer",
-    proposalId: "sg:proposal/retrieval-improvement",
-    sourceTask: idOf(state.task, "sg:task/execution-fixture"),
-    validation: { status: "PASS", validator: "agent:validator", version: "validator@v1" },
-  };
-  const proposalCall = await callExport(modules.learning, "learning", "createProposal", proposalInput);
-  const proposal = proposalCall.ok ? payload(proposalCall.value) : null;
-  const directPromotionCall = await callExport(modules.learning, "learning", "promoteProposal", { proposal });
-  const directPromotion = directPromotionCall.ok ? payload(directPromotionCall.value) : null;
-  rows.push(directPromotionCall.ok
-    ? result(
-      "promotion_requires_verify_and_decision",
-      "proposal cannot promote before an independent verification and accepted governance decision",
-      directPromotion,
-      !(isObject(directPromotion) && (directPromotion.promoted === true || directPromotion.status === "PROMOTED")),
-    )
-    : failFromCall("promotion_requires_verify_and_decision", "proposal cannot promote before an independent verification and accepted governance decision", directPromotionCall));
-  if (!proposalCall.ok) {
-    rows.push(failFromCall("learning_proposal_is_immutable_and_provenanced", "proposal records claim, evidence, validation, proposer, and proposed change", proposalCall));
-    return rows;
-  }
-  rows.push(result(
-    "learning_proposal_is_immutable_and_provenanced",
-    "proposal records claim, evidence, validation, proposer, and proposed change",
-    proposal,
-    isObject(proposal)
-      && isObject(pick(proposal, ["claim"]))
-      && Array.isArray(pick(proposal, ["evidence", "evidenceLinks", "evidence_links"]))
-      && isObject(pick(proposal, ["validation"]))
-      && typeof pick(proposal, ["proposer", "proposedBy", "proposed_by"]) === "string"
-      && Array.isArray(pick(proposal, ["changes", "patch", "delta"])),
-  ));
-
-  const sameActorCall = await callExport(modules.learning, "learning", "verifyProposal", {
-    proposal,
-    verifier: "agent:proposer",
-    verifierActor: "agent:proposer",
-    evidence: proposalInput.evidence,
-    validation: proposalInput.validation,
-  });
-  const sameActor = sameActorCall.ok ? payload(sameActorCall.value) : null;
-  rows.push(sameActorCall.ok
-    ? result(
-      "learning_verification_requires_independence",
-      "proposer cannot satisfy the independent verification gate",
-      sameActor,
-      !(isObject(sameActor) && (sameActor.verified === true || sameActor.status === "VERIFIED" || sameActor.ok === true)),
-    )
-    : failFromCall("learning_verification_requires_independence", "proposer cannot satisfy the independent verification gate", sameActorCall));
-
-  const verifyCall = await callExport(modules.learning, "learning", "verifyProposal", {
-    independentOf: "agent:proposer",
-    proposal,
-    verifier: "agent:verifier",
-    verifierActor: "agent:verifier",
-    evidence: [{ ...proposalInput.evidence[0], independentGroup: "verification-group" }],
-    validation: { status: "PASS", validator: "agent:validator", version: "validator@v1" },
-  });
-  const verification = verifyCall.ok ? payload(verifyCall.value) : null;
-  rows.push(verifyCall.ok
-    ? result(
-      "learning_verification_is_independent_and_validated",
-      "different actor supplies positive verification with passing validation",
-      verification,
-      isObject(verification)
-        && (pick(verification, ["verified", "isVerified"]) === true || stateOf(verification) === "VERIFIED" || stateOf(verification) === "verified")
-        && typeof pick(verification, ["verifier", "verifiedBy", "verified_by"]) === "string"
-        && pick(verification, ["verifier", "verifiedBy", "verified_by"]) !== pick(proposal, ["proposer", "proposedBy", "proposed_by"]),
-    )
-    : failFromCall("learning_verification_is_independent_and_validated", "different actor supplies positive verification with passing validation", verifyCall));
-
-  const decisionCall = await callExport(modules.learning, "learning", "decideProposal", {
-    decision: "ACCEPT",
-    governanceDecision: { actor: "governor:test", decision: "ACCEPT", scope: "retriever", decidedAt: fixedNow },
-    proposal,
-    verification,
-  });
-  const decision = decisionCall.ok ? payload(decisionCall.value) : null;
-  rows.push(decisionCall.ok
-    ? result(
-      "learning_governance_decision_is_explicit",
-      "promotion is gated by an explicit accepted governance decision",
-      decision,
-      isObject(decision) && hasAnyText(decision, ["decision", "status", "disposition"], ["ACCEPT", "ACCEPTED", "accepted"]),
-    )
-    : failFromCall("learning_governance_decision_is_explicit", "promotion is gated by an explicit accepted governance decision", decisionCall));
-
-  const registryBefore = { entries: [{ stableRef: "sg:retriever/fixture", versionId: "sg:retriever/fixture@sha256:4444444444444444444444444444444444444444444444444444444444444444" }] };
-  const registryDigestBefore = bytes(registryBefore);
-  const promotionCall = await callExport(modules.learning, "learning", "promoteProposal", {
-    decision,
-    governanceDecision: decision,
-    proposal,
-    registry: registryBefore,
-    verification,
-  });
-  const promotion = promotionCall.ok ? payload(promotionCall.value) : null;
-  rows.push(promotionCall.ok
-    ? result(
-      "learning_promotion_never_auto_asserts_truth",
-      "accepted promotion creates a new governed version/receipt without mutating prior registry or asserting factual truth",
-      promotion,
-      isObject(promotion)
-        && (promotion.promoted === true || hasAnyText(promotion, ["status", "state"], ["PROMOTED", "promoted"]))
-        && bytes(registryBefore) === registryDigestBefore
-        && pick(promotion, ["autoTruth", "auto_truth", "truthAccepted", "truth_accepted"]) !== true,
-    )
-    : failFromCall("learning_promotion_never_auto_asserts_truth", "accepted promotion creates a new governed version/receipt without mutating prior registry or asserting factual truth", promotionCall));
-  return rows;
-}

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

@@ -1,143 +0,0 @@
-import {
-  callExport,
-  failFromCall,
-  fixedNow,
-  grantInput,
-  hasAnyText,
-  hasText,
-  idOf,
-  isObject,
-  operationInput,
-  payload,
-  pick,
-  result,
-  stateOf,
-} from "./test-agent-execution-fixtures.mjs";
-
-export async function exerciseExecutionLifecycle(modules) {
-  const rows = [];
-  const operationSpec = operationInput();
-  const grant = grantInput();
-  const operationCall = await callExport(modules.execution, "execution", "defineOperation", operationSpec);
-  const operation = operationCall.ok ? payload(operationCall.value) : null;
-  rows.push(operationCall.ok
-    ? result(
-      "operation_spec_defines_effect_and_capability",
-      "operation has stable identity, NONE effect, idempotency, and required capability",
-      {
-        effectClass: pick(operation, ["effectClass", "effect_class", "effect"]),
-        idempotent: pick(operation, ["idempotent", "isIdempotent"]),
-        requiredCapability: pick(operation, ["requiredCapability", "required_capability", "capability"]),
-        stableRef: pick(operation, ["stableRef", "stable_ref", "operation", "name"]),
-      },
-      isObject(operation)
-        && hasAnyText(operation, ["effectClass", "effect_class", "effect"], ["NONE", "none"])
-        && pick(operation, ["idempotent", "isIdempotent"]) === true
-        && hasText(operation, ["requiredCapability", "required_capability", "capability"], "wiki.read")
-        && typeof pick(operation, ["stableRef", "stable_ref", "operation", "name"]) === "string",
-    )
-    : failFromCall("operation_spec_defines_effect_and_capability", "operation has stable identity, NONE effect, idempotency, and required capability", operationCall));
-
-  const authorizedCall = await callExport(modules.execution, "execution", "authorizeOperation", {
-    capability: grant,
-    grant,
-    now: fixedNow,
-    operation,
-    resource: "sg:profile/editorial-reference-profile",
-    subject: "agent:test",
-  });
-  const authorized = authorizedCall.ok ? payload(authorizedCall.value) : null;
-  rows.push(authorizedCall.ok
-    ? result(
-      "capability_authorizes_scoped_read",
-      "allowed true with a policy decision bound to subject, operation, resource, and time",
-      authorized,
-      isObject(authorized)
-        && pick(authorized, ["allowed", "isAllowed"]) === true
-        && isObject(pick(authorized, ["decision", "policyDecision", "policy_decision"]))
-        && typeof pick(pick(authorized, ["decision", "policyDecision", "policy_decision"]), ["subject", "principal"]) === "string",
-    )
-    : failFromCall("capability_authorizes_scoped_read", "allowed true with a policy decision bound to subject, operation, resource, and time", authorizedCall));
-
-  const deniedCall = await callExport(modules.execution, "execution", "authorizeOperation", {
-    capability: grant,
-    grant,
-    now: fixedNow,
-    operation,
-    resource: "sg:governance/private",
-    subject: "agent:other",
-  });
-  const denied = deniedCall.ok ? payload(deniedCall.value) : null;
-  rows.push(deniedCall.ok
-    ? result(
-      "capability_denies_wrong_subject_and_resource",
-      "allowed false with a stable authorization failure",
-      denied,
-      isObject(denied) && pick(denied, ["allowed", "isAllowed"]) === false,
-    )
-    : failFromCall("capability_denies_wrong_subject_and_resource", "allowed false with a stable authorization failure", deniedCall));
-
-  const taskInput = {
-    intent: { operation: "resolve", resource: "sg:profile/editorial-reference-profile" },
-    operation: "resolve",
-    requiredResult: { type: "profile" },
-    stableRef: "sg:task/execution-fixture",
-    taskId: "sg:task/execution-fixture",
-  };
-  const taskCall = await callExport(modules.execution, "execution", "createTask", taskInput);
-  const task = taskCall.ok ? payload(taskCall.value) : null;
-  rows.push(taskCall.ok
-    ? result(
-      "task_preserves_intent_and_required_result",
-      "task has stable task identity, intent, required result, and initial state",
-      task,
-      isObject(task)
-        && typeof idOf(task, "sg:task/execution-fixture") === "string"
-        && isObject(pick(task, ["intent", "request"]))
-        && isObject(pick(task, ["requiredResult", "required_result", "result"]))
-        && typeof stateOf(task) === "string",
-    )
-    : failFromCall("task_preserves_intent_and_required_result", "task has stable task identity, intent, required result, and initial state", taskCall));
-
-  const runCall = await callExport(modules.execution, "execution", "startRun", {
-    input: { stableRef: "sg:profile/editorial-reference-profile" },
-    runId: "sg:run/execution-fixture-1",
-    run_id: "sg:run/execution-fixture-1",
-    task,
-    taskId: pick(task, ["taskId", "task_id", "stableRef", "stable_ref"]) ?? "sg:task/execution-fixture",
-  });
-  const run = runCall.ok ? payload(runCall.value) : null;
-  rows.push(runCall.ok
-    ? result(
-      "run_belongs_to_one_task",
-      "run has a distinct run identity linked to the task",
-      run,
-      isObject(run)
-        && pick(run, ["runId", "run_id", "stableRef", "stable_ref", "id"]) === "sg:run/execution-fixture-1"
-        && pick(run, ["taskId", "task_id"]) === (pick(task, ["taskId", "task_id", "stableRef", "stable_ref"]) ?? "sg:task/execution-fixture")
-        && typeof stateOf(run) === "string",
-    )
-    : failFromCall("run_belongs_to_one_task", "run has a distinct run identity linked to the task", runCall));
-
-  const immediateAuthCall = await callExport(modules.execution, "execution", "authorizeEffect", {
-    capability: grant,
-    grant,
-    now: fixedNow,
-    operation,
-    resource: "sg:profile/editorial-reference-profile",
-    run,
-    subject: "agent:test",
-    task,
-  });
-  const immediateAuth = immediateAuthCall.ok ? payload(immediateAuthCall.value) : null;
-  rows.push(immediateAuthCall.ok
-    ? result(
-      "effect_rechecks_authorization_immediately",
-      "effect authorization is explicitly allowed immediately before an external attempt",
-      immediateAuth,
-      isObject(immediateAuth) && pick(immediateAuth, ["allowed", "isAllowed"]) === true,
-    )
-    : failFromCall("effect_rechecks_authorization_immediately", "effect authorization is explicitly allowed immediately before an external attempt", immediateAuthCall));
-
-  return { rows, operation, grant, task, run, authorized };
-}

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

@@ -1,158 +0,0 @@
-#!/usr/bin/env node
-
-import {
-  authorizeOperation,
-  defineOperation,
-  reconcileEffect,
-  recordEffectAttempt,
-} from "./agent-native/execution.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 operation() {
-  return defineOperation({
-    effect_class: "EXTERNAL",
-    name: "publish",
-    required_capability: "wiki.publish",
-    stable_ref: "sg:operation/publish",
-  });
-}
-
-function grant(operations) {
-  return {
-    capability: "wiki.publish",
-    operations,
-    resource_scope: ["sg:profile/*"],
-    subject: "agent:test",
-  };
-}
-
-function authorization(operations) {
-  return authorizeOperation({
-    grant: grant(operations),
-    operation: operation(),
-    resource: "sg:profile/editorial-reference-profile",
-    subject: "agent:test",
-  });
-}
-
-function externalEffect(overrides = {}) {
-  return recordEffectAttempt({
-    effect_class: "EXTERNAL",
-    effect_id: "sg:effect/publish-1",
-    run_id: "sg:run/publish-1",
-    task_id: "sg:task/publish-1",
-    ...overrides,
-  });
-}
-
-test("empty_operation_scope_denies_protected_operation", () => {
-  // Given a capability with matching subject, resource, and capability but no operations.
-  // When authorization evaluates the protected publish operation.
-  const result = authorization([]);
-  // Then omission is deny-by-default rather than a wildcard grant.
-  equal(result.allowed, false, "allowed");
-  equal(result.failures.includes("operation_denied"), true, "operation_denied");
-});
-
-test("explicit_operation_scope_authorizes_matching_operation", () => {
-  // Given an explicitly scoped capability.
-  // When the named operation is evaluated.
-  const result = authorization(["publish"]);
-  // Then the operation is authorized.
-  equal(result.allowed, true, "allowed");
-});
-
-test("external_effect_ignores_forged_committed_state_without_receipt", () => {
-  // Given an external attempt with no connector receipt and caller state COMMITTED.
-  // When the attempt is recorded.
-  const effect = externalEffect({ connector_receipt: null, state: "COMMITTED" });
-  // Then the kernel derives UNCERTAIN.
-  equal(effect.state, "UNCERTAIN", "state");
-});
-
-test("empty_connector_receipt_cannot_commit_external_effect", () => {
-  // Given an external attempt with an empty receipt identifier.
-  // When the caller requests COMMITTED.
-  const effect = externalEffect({ connector_receipt: "", state: "COMMITTED" });
-  // Then empty evidence is treated as absent.
-  equal(effect.state, "UNCERTAIN", "state");
-});
-
-test("blank_connector_receipt_cannot_commit_external_effect", () => {
-  // Given an external attempt with only whitespace as receipt evidence.
-  // When the caller requests COMMITTED.
-  const effect = externalEffect({ connector_receipt: "   ", state: "COMMITTED" });
-  // Then blank evidence is treated as absent.
-  equal(effect.state, "UNCERTAIN", "state");
-});
-
-test("durable_receipt_commits_external_effect", () => {
-  // Given an external attempt backed by a durable connector receipt ID.
-  // When the caller supplies a conflicting state.
-  const effect = externalEffect({ connector_receipt: "sg:connector-receipt/publish-1", state: "UNCERTAIN" });
-  // Then receipt evidence, not caller state, derives COMMITTED.
-  equal(effect.state, "COMMITTED", "state");
-});
-
-test("positive_observation_without_receipt_stays_uncertain", () => {
-  // Given an uncertain external effect and an unreceipted positive observation.
-  // When reconciliation runs.
-  const reconciled = reconcileEffect({
-    effect: externalEffect(),
-    observations: [{ status: "COMMITTED" }],
-  });
-  // Then status alone cannot commit the effect.
-  equal(reconciled.state, "UNCERTAIN", "state");
-});
-
-test("positive_receipted_observation_commits", () => {
-  // Given an uncertain effect and a positive durable receipt observation.
-  // When reconciliation runs.
-  const reconciled = reconcileEffect({
-    effect: externalEffect(),
-    observations: [{ connector_receipt: "sg:connector-receipt/recovered", status: "COMMITTED" }],
-  });
-  // Then the effect is committed and bound to that receipt.
-  equal(reconciled.state, "COMMITTED", "state");
-  equal(reconciled.connector_receipt, "sg:connector-receipt/recovered", "connector_receipt");
-});
-
-test("legacy_unreceipted_committed_effect_is_demoted", () => {
-  // Given legacy data claiming COMMITTED without receipt evidence.
-  // When it is reconciled without new observations.
-  const reconciled = reconcileEffect({
-    effect: {
-      effect_class: "EXTERNAL",
-      effect_id: "sg:effect/legacy",
-      state: "COMMITTED",
-    },
-  });
-  // Then reconciliation restores the safe UNCERTAIN state.
-  equal(reconciled.state, "UNCERTAIN", "state");
-});
-
-const report = {
-  contract: "agent-native-execution-safety",
-  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-views.mjs

@@ -1,117 +0,0 @@
-import {
-  bytes,
-  callExport,
-  failFromCall,
-  fixedNow,
-  idOf,
-  isObject,
-  payload,
-  pick,
-  result,
-} from "./test-agent-execution-fixtures.mjs";
-
-export async function exerciseEvents(modules, state) {
-  const rows = [];
-  let events = [];
-  const entries = [
-    { eventId: "sg:event/task-created", parents: [], payload: { taskId: idOf(state.task, "sg:task/execution-fixture") }, type: "task.created" },
-    { eventId: "sg:event/run-started", parents: ["sg:event/task-created"], payload: { runId: idOf(state.run, "sg:run/execution-fixture-1") }, type: "run.started" },
-    { eventId: "sg:event/effect-reconciled", parents: ["sg:event/task-created"], payload: { effectState: "COMMITTED" }, type: "effect.reconciled" },
-  ];
-  for (const event of entries) {
-    const call = await callExport(modules.events, "events", "appendEvent", { event, events });
-    if (!call.ok) {
-      rows.push(failFromCall("event_dag_append_is_immutable", "appendEvent returns an append-only event collection", call));
-      return rows;
-    }
-    const value = payload(call.value);
-    if (Array.isArray(value)) events = value;
-    else if (Array.isArray(value?.events)) events = value.events;
-    else if (isObject(value?.event)) events = [...events, value.event];
-    else if (isObject(value)) events = [...events, value];
-    else events = [...events, event];
-  }
-  const appendResult = events.map((event) => ({ id: pick(event, ["eventId", "event_id", "id", "stableRef", "stable_ref"]), parents: pick(event, ["parents", "parentIds", "parent_ids"]) }));
-  rows.push(result(
-    "event_dag_append_is_immutable",
-    "three immutable events preserve explicit parent links and event IDs",
-    appendResult,
-    events.length === 3
-      && appendResult.every((event) => typeof event.id === "string" && Array.isArray(event.parents))
-      && appendResult[1].parents.includes("sg:event/task-created")
-      && appendResult[2].parents.includes("sg:event/task-created"),
-  ));
-
-  const headsCall = await callExport(modules.events, "events", "eventHeads", { events });
-  if (!headsCall.ok) {
-    rows.push(failFromCall("event_dag_heads_are_deterministic", "eventHeads returns the two concurrent heads in stable order", headsCall));
-    return rows;
-  }
-  const heads = payload(headsCall.value);
-  const headValues = Array.isArray(heads) ? heads : pick(heads, ["heads", "eventHeads", "event_heads"]);
-  rows.push(result(
-    "event_dag_heads_are_deterministic",
-    "eventHeads returns the two concurrent heads in stable order",
-    headValues,
-    Array.isArray(headValues)
-      && headValues.length === 2
-      && headValues.map(String).sort().join(",") === "sg:event/effect-reconciled,sg:event/run-started",
-  ));
-  return rows;
-}
-
-export async function exerciseRetrieval(modules) {
-  const rows = [];
-  const members = [
-    { content: "Editorial profile uses constrained columns.", stableRef: "sg:profile/editorial-reference-profile", versionId: "sg:profile/editorial-reference-profile@sha256:1111111111111111111111111111111111111111111111111111111111111111" },
-    { content: "Resolve returns governed profile metadata.", stableRef: "sg:claim/resolve-profile", versionId: "sg:claim/resolve-profile@sha256:2222222222222222222222222222222222222222222222222222222222222222" },
-  ];
-  const snapshotInput = {
-    asOf: fixedNow,
-    builderVersion: "retriever-fixture@1",
-    heads: ["sg:event/effect-reconciled", "sg:event/run-started"],
-    members,
-    policy: "sg:governance/read-policy@sha256:3333333333333333333333333333333333333333333333333333333333333333",
-    viewSpec: { queryClass: "exact", stableRef: "sg:view/profile-context", version: "v1" },
-  };
-  const snapshotCallA = await callExport(modules.retrieval, "retrieval", "buildViewSnapshot", snapshotInput);
-  const snapshotCallB = await callExport(modules.retrieval, "retrieval", "buildViewSnapshot", { ...snapshotInput, members: [...members].reverse(), heads: [...snapshotInput.heads].reverse() });
-  const snapshotA = snapshotCallA.ok ? payload(snapshotCallA.value) : null;
-  const snapshotB = snapshotCallB.ok ? payload(snapshotCallB.value) : null;
-  if (!snapshotCallA.ok) rows.push(failFromCall("retrieval_snapshot_is_deterministic", "same inputs produce byte-identical snapshot", snapshotCallA));
-  else if (!snapshotCallB.ok) rows.push(failFromCall("retrieval_snapshot_is_deterministic", "same inputs produce byte-identical snapshot", snapshotCallB));
-  else rows.push(result(
-    "retrieval_snapshot_is_deterministic",
-    "same logical inputs produce byte-identical immutable snapshot with provenance",
-    { first: snapshotA, second: snapshotB, equal: bytes(snapshotA) === bytes(snapshotB) },
-    bytes(snapshotA) === bytes(snapshotB)
-      && isObject(snapshotA)
-      && typeof pick(snapshotA, ["versionId", "version_id", "snapshotRef", "snapshot_ref", "digest", "sha256"]) === "string"
-      && Array.isArray(pick(snapshotA, ["members", "entries", "items"])),
-  ));
-
-  const contextCall = await callExport(modules.retrieval, "retrieval", "buildContextPackage", {
-    budget: { tokens: 240 },
-    members,
-    policy: snapshotInput.policy,
-    queryClass: "exact",
-    query: "Which profile is editorial?",
-    retriever: "retriever:fixture@v1",
-    snapshot: snapshotA,
-  });
-  const context = contextCall.ok ? payload(contextCall.value) : null;
-  rows.push(contextCall.ok
-    ? result(
-      "context_package_is_bounded_and_provenance_linked",
-      "context package preserves snapshot/policy/member manifest and token budget",
-      context,
-      isObject(context)
-        && isObject(pick(context, ["budget"]))
-        && Number.isInteger(pick(pick(context, ["budget"]), ["tokens", "tokenBudget", "token_budget"]))
-        && Array.isArray(pick(context, ["members", "entries", "items"]))
-        && pick(context, ["snapshot", "snapshotRef", "snapshot_ref"]) !== undefined
-        && pick(context, ["policy", "policyRef", "policy_ref"]) !== undefined,
-    )
-    : failFromCall("context_package_is_bounded_and_provenance_linked", "context package preserves snapshot/policy/member manifest and token budget", contextCall));
-  return { rows, snapshot: snapshotA, context };
-}