stylegallery 0.1.0

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

@@ -0,0 +1,39 @@
+#!/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

@@ -0,0 +1,130 @@
+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

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,158 @@
+#!/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

@@ -0,0 +1,117 @@
+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 };
+}