Decisions Bound to Bytes

Bind a review’s verdict or a person’s approval to the exact bytes it judged, and get it back only while those bytes still match. Use it when a result or a decision will be acted on later, or by another process, and a changed input must void it. For the question itself, read Callback gates; this page is what makes an answer stick to its subject. A proof artifact has one content digest. An accepted-result record binds a review outcome to that proof and the bytes it covered. An approval record binds a stored action decision to the same kind of exact subject. While every covered byte still matches, you can reuse the result or act on the approval. Change one of those bytes and you get wait instead.

Accept a result

writeProofArtifact stores the stable JSON bytes of one proof packet, and createAcceptedResultRecord binds a review outcome to it:

examples/proof-bound-approval.ts (excerpt)

  const proofArtifact = await writeProofArtifact(
    storage.artifactStore,
    { namespace: storage.record.namespace, runId },
    {
      inputs: { proposal: digest('1') },
      result: { passed: true, tests: 21 },
    },
  );
  const acceptedBinding = {
    inputHashes,
    proofScope,
    proofArtifact,
    graph: {
      definitionDigest: plan.plan.graph.definitionDigest,
      typeVersion: plan.plan.graph.typeVersion,
    },
    workspaceAnchor,
  } as const;
  const firstReview = await createAcceptedResultRecord(
    storage,
    runId,
    architectureReview.position,
    {
      ...acceptedBinding,
      result: { verdict: 'pass' },
      reviewerIdentity: { provider: 'anthropic', model: 'reviewer-a' },
    },
  );

The proof reference carries the content digest, byte length, media type and proof-packet purpose. Reordered object fields produce the same bytes and digest; changed proof data produces another. You choose the packet fields and the proof scope, and writeProofArtifact doesn’t check how the proof was produced. An accepted result is stored only when the graph matches the stored run plan and the run holds exactly one dispatch for that position, followed by a completed event with the same node and result. Missing, failed or conflicting completions are refused with INVALID_STORED_VALUE. The record binds the result to input hashes, proof scope and artifact, graph definition and type version, workspace anchor, and the reviewer identity you supply; the reviewer fingerprint is the digest of that identity. Writing the same complete record again at the same position does nothing. A different binding for the same completed result there is refused with REVISION_CONFLICT. Accepted results need a WorkspaceAnchor: workspace root, repository identity, HEAD revision, content fingerprint, capture scope and file states, with schemaVersion: 1. The validators bind its bytes into the record digest but don’t validate its fields, compare it with the run’s workspace binding or verify the checkout. For a real workspace, use an anchor your workspace provider captured, and verify it before you reuse a result. The example’s /workspace anchor is made-up data to show digest matching.

Bind an approval

createApprovalCallbackGate puts the subject digest into the callback request before its identity is created, so the question is about these exact bytes:

examples/proof-bound-approval.ts (excerpt)

  const approvalDefinition: CallbackGateDefinition = {
    gateId: 'apply-reviewed-output',
    gateVersion: 1,
    decisionText: 'Apply these exact reviewed bytes?',
    responseSchema: {
      type: 'object',
      properties: { kind: { type: 'string' } },
      required: ['kind'],
    },
    input: { change: 'runtime-update' },
  };
  const request = createApprovalCallbackGate(approvalDefinition, approvalSubject);
  const callbacks = await createStoredCallbackClient(storage, runId);
  await callbacks.post(request, approvalSubject);
  const claim = await callbacks.claim(request.requestId, 'human-review');
  if (!claim.ok) throw new Error('The approval request was not claimed.');
  const submitted = await callbacks.submit(
    request.requestId,
    claim.claimToken,
    'human-review',
    request.digest,
    { kind: 'allow' },
    { id: 'release-owner', kind: 'human' },
  );

The subject covers input artifact hashes, proof scope and artifact, the proposed output bytes, the effective permissions, and a workspace anchor or null. post stores that exact subject with the request, and submit stores the answer and the approval record in one event batch. The record also binds the stored run plan, graph, the actor you supply, the router path and the action decision. Each effective permission must match one permission admitted by the stored run plan, name and JSON scope exactly, key order aside; the subject may use a subset.

Resolve before you act

resolveAcceptedResult and resolveApproval return the stored value only while the current subject matches the record:

examples/proof-bound-approval.ts (excerpt)

  const unchangedAccepted = await resolveAcceptedResult(
    reopenedStorage,
    runId,
    architectureReview.position,
    { ...acceptedBinding, reviewerIdentity: { provider: 'anthropic', model: 'reviewer-a' } },
  );
  const changedAnchor = await resolveAcceptedResult(
    reopenedStorage,
    runId,
    architectureReview.position,
    {
      ...acceptedBinding,
      workspaceAnchor: { ...workspaceAnchor, fingerprint: 'c'.repeat(64) },
      reviewerIdentity: { provider: 'anthropic', model: 'reviewer-a' },
    },
  );
  const unchangedApproval = await resolveApproval(
    reopenedStorage,
    runId,
    { request, ...approvalSubject },
  );
  const changedApproval = await resolveApproval(
    reopenedStorage,
    runId,
    { request, ...changedSubject },
  );

Run the file with npx tsx proof-bound-approval.ts; it calls no model and writes to a temporary directory it removes:

Output

{"proof":{"digest":"sha256:db5b2a0eb5743b52617a78335dbc003a9a10619dc6cab05f6099f81c9b7fb329","byteLength":133,"recordsShareDigest":true},"callback":{"responseSurvivedReopen":true,"changedRequest":true},"acceptedResult":{"unchanged":"accepted","changedAnchor":"wait"},"approval":{"unchanged":"allow","changedOutput":"wait"}}

Two accepted-result records cite one proof digest. The callback answer survived reopening the storage. The unchanged result resolves to accepted and the unchanged approval to allow; a changed workspace anchor and a changed proposed output each return wait. A wait needs fresh proof or a decision by the host, and a changed binding needs a newly completed proof position; it can’t replace the acceptance stored for an earlier completion. The host owns every effect after approval: these APIs don’t make a backup, apply output, read the effect back, reconcile an uncertain effect or merge files. createProofCache serves bounded proof packets for one host process and one stored run, so fresh workers get the same evidence without reading unchanged sources again:

examples/proof-cache.ts (excerpt)

  const cache = createProofCache({
    storage,
    runId,
    sources,
    maxPacketBytes: 16_000,
    proofJobs: [
      { id: 'review', mode: 'read-only', sourceIds: ['config', 'policy'], proofScope: { kind: 'config-review' } },
      { id: 'policy', mode: 'read-only', sourceIds: ['policy'], proofScope: { kind: 'policy-review' } },
      { id: 'apply', mode: 'effectful', sourceIds: ['config'], proofScope: { kind: 'write' } },
    ],
  });
  const [first, second, policyPacket] = await Promise.all([
    cache.packet('review'), cache.packet('review'), cache.packet('policy'),
  ]);

Declare each source by id with a revision() that returns an authoritative content revision and a read(expectedRevision, maxBytes) that returns complete JSON or text for that revision. The cache checks revisions before and after capture and hashes the content; it refuses an oversized packet or a capture that races a source change, and never truncates. Declare each proof job’s sources, scope and mode: only read-only jobs can request packets or stored results, and the cache executes no job. Concurrent requests share source reads, a changed source invalidates only the packets that depend on it, and a host restart starts a cold cache while stored artifacts and records stay in run storage. resolveAccepted(jobId, position, current) derives the hashes, scope and artifact from the current packet and checks the stored acceptance again with the graph, verified anchor and reviewer identity you pass. Reviewers share evidence and keep separate answers: a different reviewer identity doesn’t inherit another’s result. Run npx tsx proof-cache.ts:

Output

{"sourceReads":{"config":2,"policy":1},"proofRuns":1,"sharedPacket":true,"reused":"accepted","changedSource":"wait","unaffectedPacket":true,"changedReviewer":"wait","effectfulRefused":true}

Two packet requests shared one artifact. The stored review was reused, refused for a different reviewer, and refused again after the configuration changed, while the independent policy packet was kept. The effectful job was refused a packet.

Failure

INVALID_STORED_VALUE: the run has no single completed dispatch for the position an accepted result names.
REVISION_CONFLICT: a different binding for a result already accepted at that position.
SUBJECT_MISMATCH: post throws ApprovalSubjectError for a permission outside the stored plan; submit returns invalid and resolveApproval returns wait in the same case.
KNOWN_SECRET: the local event store rejects a write whose reviewer identity or actor contains a configured secret, nested values and keys included. A rejected approval write stores neither the answer nor the record.

Limits

Identities are stored whole. The supplied reviewerIdentity and actor objects are kept beside their fingerprints, unauthenticated. Supply only non-secret identifiers; the store can’t catch a credential that isn’t on its knownSecrets list.
The proof cache trusts its adapters. Source declarations and revision behaviour are the host’s trusted code. A node’s retrySafe governs crash recovery; it doesn’t make a job read-only.

Full file: proof-bound-approval.ts

examples/proof-bound-approval.ts

import { mkdtemp, realpath, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

import {
  compileGraph,
  createAcceptedResultRecord,
  createApprovalCallbackGate,
  createStoredCallbackClient,
  createGraphExecutor,
  dagGraphType,
  persistRunDefinition,
  resolveAcceptedResult,
  resolveApproval,
  resolveGraphPlan,
  writeProofArtifact,
  type ApprovalSubjectInput,
  type CallbackGateDefinition,
  type Sha256Digest,
  type WorkspaceAnchor,
} from '@obversa/runtime';
import { createLocalRunStorage } from '@obversa/runtime/storage/local';

const digest = (digit: string): Sha256Digest => (
  `sha256:${digit.repeat(64)}` as Sha256Digest
);

const storagePolicy = {
  schemaVersion: 1,
  maxEventPayloadBytes: 64_000,
  maxAppendBatchBytes: 128_000,
  maxArtifactBytes: 1_000_000,
  maxTotalArtifactBytesPerRun: 4_000_000,
  retention: 'until-run-delete',
  sensitiveContent: {
    marked: 'reject',
    exact: 'reject',
    freeText: 'redact-before-hash',
  },
} as const;

const graph = compileGraph(dagGraphType, {
  id: 'proof-bound-approval',
  definitionVersion: 1,
  data: {
    globalConcurrency: 2,
    keyedConcurrency: {},
    stopOnError: true,
    retryCapPerNode: 0,
  },
  nodes: [
    { id: 'architecture', data: { kind: 'required', key: null } },
    { id: 'correctness', data: { kind: 'required', key: null } },
  ],
  edges: [],
});
const packageIdentity = {
  source: 'npm:@example/proof-bound-approval',
  version: '1.0.0',
  digest: digest('7'),
} as const;
const plan = resolveGraphPlan(graph.describe(), {
  package: packageIdentity,
  admission: {
    package: packageIdentity,
    permissions: [{ name: 'workspace.write', scope: { paths: ['packages/runtime'] } }],
  },
  executionLanes: [],
});
const workspaceAnchor: WorkspaceAnchor = {
  schemaVersion: 1,
  root: '/workspace',
  repositoryId: '/workspace/.git',
  head: 'a'.repeat(40),
  fingerprint: 'b'.repeat(64),
  scope: null,
  files: [],
};
const proofScope = { kind: 'change', paths: ['packages/runtime'] } as const;
const inputHashes = { proposal: digest('1') };
const runId = 'proof-bound-approval-run';

const directory = await realpath(await mkdtemp(join(tmpdir(), 'obversa-proof-approval-')));
try {
  const openStorage = () => createLocalRunStorage({
    directory: join(directory, 'storage'),
    namespace: 'proof-approval-example',
    policy: storagePolicy,
  });
  const storage = openStorage();
  await persistRunDefinition(storage, {
    runId,
    eventId: 'proof-bound-approval-started',
    timestamp: '2026-01-01T00:00:00.000Z',
    graphDefinition: graph.definition,
    resolvedPlan: plan,
    resolvedInputs: {},
    workspaceBinding: null,
    hostBinding: null,
  });
  const initialCommands = graph.decide(graph.initialState());
  const architectureReview = initialCommands.find((command) => (
    command.kind === 'dispatch' && command.nodeId === 'architecture'
  ));
  const correctnessReview = initialCommands.find((command) => (
    command.kind === 'dispatch' && command.nodeId === 'correctness'
  ));
  if (architectureReview?.kind !== 'dispatch' || correctnessReview?.kind !== 'dispatch') {
    throw new Error('The review graph did not dispatch both review nodes.');
  }
  const reviewNode = {
    prompt: null,
    scratchDirectory: directory,
    workspace: { mode: 'none', directory: null, allowedPaths: [] },
    trustedCaller: {},
    permissions: [],
    policy: {
      inputBytes: 100_000,
      outputBytes: 100_000,
      timeoutMs: 5_000,
      teardownGraceMs: 100,
      memoryBytes: 100_000_000,
      filesChanged: 0,
      linesChanged: 0,
      callTokens: null,
    },
    resultContract: null,
    runData: async () => ({ verdict: 'pass' }),
    parseResult: null,
    tokenBudget: null,
    decideAction: async () => ({ kind: 'allow' } as const),
  } as const;
  const executor = await createGraphExecutor({
    runId,
    graph,
    storage,
    nodes: { architecture: reviewNode, correctness: reviewNode },
    engines: [],
  });
  const completed = await executor.run(new AbortController().signal);
  if (completed.kind !== 'complete') throw new Error('The review nodes did not complete.');

  const proofArtifact = await writeProofArtifact(
    storage.artifactStore,
    { namespace: storage.record.namespace, runId },
    {
      inputs: { proposal: digest('1') },
      result: { passed: true, tests: 21 },
    },
  );
  const acceptedBinding = {
    inputHashes,
    proofScope,
    proofArtifact,
    graph: {
      definitionDigest: plan.plan.graph.definitionDigest,
      typeVersion: plan.plan.graph.typeVersion,
    },
    workspaceAnchor,
  } as const;
  const firstReview = await createAcceptedResultRecord(
    storage,
    runId,
    architectureReview.position,
    {
      ...acceptedBinding,
      result: { verdict: 'pass' },
      reviewerIdentity: { provider: 'anthropic', model: 'reviewer-a' },
    },
  );
  const secondReview = await createAcceptedResultRecord(
    storage,
    runId,
    correctnessReview.position,
    {
      ...acceptedBinding,
      result: { verdict: 'pass' },
      reviewerIdentity: { provider: 'openai', model: 'reviewer-b' },
    },
  );

  const proposedOutput = new TextEncoder().encode('approved output');
  const approvalSubject: ApprovalSubjectInput = {
    workspaceAnchor,
    inputArtifactHashes: inputHashes,
    proofScope,
    proofArtifact,
    proposedOutput,
    effectivePermissions: [{
      name: 'workspace.write',
      scope: { paths: ['packages/runtime'] },
    }],
  };
  const approvalDefinition: CallbackGateDefinition = {
    gateId: 'apply-reviewed-output',
    gateVersion: 1,
    decisionText: 'Apply these exact reviewed bytes?',
    responseSchema: {
      type: 'object',
      properties: { kind: { type: 'string' } },
      required: ['kind'],
    },
    input: { change: 'runtime-update' },
  };
  const request = createApprovalCallbackGate(approvalDefinition, approvalSubject);
  const callbacks = await createStoredCallbackClient(storage, runId);
  await callbacks.post(request, approvalSubject);
  const claim = await callbacks.claim(request.requestId, 'human-review');
  if (!claim.ok) throw new Error('The approval request was not claimed.');
  const submitted = await callbacks.submit(
    request.requestId,
    claim.claimToken,
    'human-review',
    request.digest,
    { kind: 'allow' },
    { id: 'release-owner', kind: 'human' },
  );
  if (!submitted.ok) throw new Error(`The approval was refused: ${submitted.reason}`);

  const reopenedStorage = openStorage();
  const reopenedCallbacks = await createStoredCallbackClient(reopenedStorage, runId);
  const changedSubject: ApprovalSubjectInput = {
    ...approvalSubject,
    proposedOutput: new TextEncoder().encode('changed output'),
  };
  const changedRequest = createApprovalCallbackGate(approvalDefinition, changedSubject);
  await reopenedCallbacks.post(changedRequest, changedSubject);
  const unchangedAccepted = await resolveAcceptedResult(
    reopenedStorage,
    runId,
    architectureReview.position,
    { ...acceptedBinding, reviewerIdentity: { provider: 'anthropic', model: 'reviewer-a' } },
  );
  const changedAnchor = await resolveAcceptedResult(
    reopenedStorage,
    runId,
    architectureReview.position,
    {
      ...acceptedBinding,
      workspaceAnchor: { ...workspaceAnchor, fingerprint: 'c'.repeat(64) },
      reviewerIdentity: { provider: 'anthropic', model: 'reviewer-a' },
    },
  );
  const unchangedApproval = await resolveApproval(
    reopenedStorage,
    runId,
    { request, ...approvalSubject },
  );
  const changedApproval = await resolveApproval(
    reopenedStorage,
    runId,
    { request, ...changedSubject },
  );

  console.log(JSON.stringify({
    proof: {
      digest: proofArtifact.digest,
      byteLength: proofArtifact.byteLength,
      recordsShareDigest: firstReview.binding.proofArtifact.digest
        === secondReview.binding.proofArtifact.digest,
    },
    callback: {
      responseSurvivedReopen: (await reopenedCallbacks.history(request.requestId)).some((event) => (
        event.kind === 'callback-submitted'
      )),
      changedRequest: (await reopenedCallbacks.listPending()).some((pending) => (
        pending.requestId === changedRequest.requestId
      )),
    },
    acceptedResult: {
      unchanged: unchangedAccepted.kind,
      changedAnchor: changedAnchor.kind,
    },
    approval: {
      unchanged: unchangedApproval.kind,
      changedOutput: changedApproval.kind,
    },
  }));
} finally {
  await rm(directory, { recursive: true, force: true });
}

Full file: proof-cache.ts

examples/proof-cache.ts

import assert from 'node:assert/strict';
import { execFile } from 'node:child_process';
import { mkdir, mkdtemp, realpath, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { promisify } from 'node:util';

import {
  compileGraph,
  createAcceptedResultRecord,
  createGitWorktreeProvider,
  createGraphExecutor,
  createProofCache,
  dagGraphType,
  persistRunDefinition,
  resolveGraphPlan,
  type GraphNodeBinding,
  type ProofSource,
  type Sha256Digest,
} from '@obversa/runtime';
import { createLocalRunStorage } from '@obversa/runtime/storage/local';

const git = promisify(execFile);
const directory = await realpath(await mkdtemp(join(tmpdir(), 'obversa-proof-cache-')));

try {
  const repository = join(directory, 'repository');
  await mkdir(repository);
  await git('git', ['init', '-q', '-b', 'main'], { cwd: repository });
  await writeFile(join(repository, 'README.md'), '# Proof cache example\n');
  await git('git', ['add', 'README.md'], { cwd: repository });
  await git('git', [
    '-c', 'user.name=Example', '-c', 'user.email=example@example.com',
    'commit', '-qm', 'initial',
  ], { cwd: repository });
  const workspace = createGitWorktreeProvider({ repositoryPath: repository });
  const workspaceAnchor = await workspace.capture();
  assert.equal((await workspace.verify(workspaceAnchor)).ok, true);

  const graph = compileGraph(dagGraphType, {
    id: 'cached-proof',
    definitionVersion: 1,
    data: {
      globalConcurrency: 1,
      keyedConcurrency: {},
      stopOnError: true,
      retryCapPerNode: 0,
    },
    nodes: [{ id: 'review', data: { kind: 'required', key: null } }],
    edges: [],
  });
  const packageIdentity = {
    source: 'npm:@example/cached-proof',
    version: '1.0.0',
    digest: `sha256:${'7'.repeat(64)}` as Sha256Digest,
  };
  const plan = resolveGraphPlan(graph.describe(), {
    package: packageIdentity,
    admission: { package: packageIdentity, permissions: [] },
    executionLanes: [],
  });
  const runId = 'cached-proof-run';
  const storage = createLocalRunStorage({
    directory: join(directory, 'storage'),
    namespace: 'proof-cache-example',
    policy: {
      schemaVersion: 1,
      maxEventPayloadBytes: 64_000,
      maxAppendBatchBytes: 128_000,
      maxArtifactBytes: 1_000_000,
      maxTotalArtifactBytesPerRun: 4_000_000,
      retention: 'until-run-delete',
      sensitiveContent: { marked: 'reject', exact: 'reject', freeText: 'redact-before-hash' },
    },
  });
  await persistRunDefinition(storage, {
    runId,
    eventId: 'cached-proof-started',
    timestamp: '2026-01-01T00:00:00.000Z',
    graphDefinition: graph.definition,
    resolvedPlan: plan,
    resolvedInputs: {},
    workspaceBinding: null,
    hostBinding: null,
  });

  // These in-memory sources own their revisions; every payload edit advances it.
  const config = { revision: '1', content: 'timeoutMs: 1000' };
  const policy = { revision: '1', content: 'A timeout must be positive.' };
  const sourceReads = { config: 0, policy: 0 };
  const sources: ProofSource[] = Object.entries({ config, policy }).map(([id, source]) => ({
    id,
    revision: async () => source.revision,
    read: async (expectedRevision, maxBytes) => {
      assert.equal(source.revision, expectedRevision);
      assert.ok(Buffer.byteLength(JSON.stringify(source.content)) <= maxBytes);
      sourceReads[id as keyof typeof sourceReads] += 1;
      return source.content;
    },
  }));
  const cache = createProofCache({
    storage,
    runId,
    sources,
    maxPacketBytes: 16_000,
    proofJobs: [
      { id: 'review', mode: 'read-only', sourceIds: ['config', 'policy'], proofScope: { kind: 'config-review' } },
      { id: 'policy', mode: 'read-only', sourceIds: ['policy'], proofScope: { kind: 'policy-review' } },
      { id: 'apply', mode: 'effectful', sourceIds: ['config'], proofScope: { kind: 'write' } },
    ],
  });
  const [first, second, policyPacket] = await Promise.all([
    cache.packet('review'), cache.packet('review'), cache.packet('policy'),
  ]);
  let proofRuns = 0;
  const result = { verdict: 'pass', proof: first.proofArtifact.digest };
  const node: GraphNodeBinding = {
    prompt: null,
    scratchDirectory: directory,
    workspace: { mode: 'none', directory: null, allowedPaths: [] },
    trustedCaller: {},
    permissions: [],
    policy: {
      inputBytes: 100_000, outputBytes: 100_000, timeoutMs: 5_000,
      teardownGraceMs: 100, memoryBytes: 100_000_000,
      filesChanged: 0, linesChanged: 0, callTokens: null,
    },
    resultContract: null,
    runData: async () => {
      proofRuns += 1;
      const captured = first.packet.sources.find((source) => source.id === 'config');
      const timeout = typeof captured?.content === 'string'
        ? /^timeoutMs: ([0-9]+)$/.exec(captured.content)
        : null;
      assert.ok(timeout && Number(timeout[1]) > 0, 'The captured config needs a positive timeout.');
      return result;
    },
    parseResult: null,
    tokenBudget: null,
    decideAction: async () => ({ kind: 'allow' }),
  };
  const executor = await createGraphExecutor({ runId, graph, storage, nodes: { review: node }, engines: [] });
  assert.equal((await executor.run(new AbortController().signal)).kind, 'complete');
  const dispatch = graph.decide(graph.initialState()).find((command) => command.kind === 'dispatch');
  assert.ok(dispatch?.kind === 'dispatch');
  const current = {
    graph: { definitionDigest: plan.plan.graph.definitionDigest, typeVersion: plan.plan.graph.typeVersion },
    workspaceAnchor,
    reviewerIdentity: { id: 'scripted-timeout-review', version: 1 },
  };
  await createAcceptedResultRecord(storage, runId, dispatch.position, {
    ...current,
    inputHashes: first.inputHashes,
    proofArtifact: first.proofArtifact,
    proofScope: first.proofScope,
    result,
  });
  assert.equal((await workspace.verify(workspaceAnchor)).ok, true);
  const reused = await cache.resolveAccepted('review', dispatch.position, current);
  assert.equal(reused.kind, 'accepted');
  if (reused.kind === 'accepted') assert.deepEqual(reused.record.result, result);
  const changedReviewer = await cache.resolveAccepted('review', dispatch.position, {
    ...current, reviewerIdentity: { id: 'different-reviewer', version: 1 },
  });
  config.content = 'timeoutMs: 2000';
  config.revision = '2';
  const changedSource = await cache.resolveAccepted('review', dispatch.position, current);
  const unchangedPolicy = await cache.packet('policy');
  await assert.rejects(async () => cache.packet('apply'));

  console.log(JSON.stringify({
    sourceReads,
    proofRuns,
    sharedPacket: first.proofArtifact.digest === second.proofArtifact.digest,
    reused: reused.kind,
    changedSource: changedSource.kind,
    unaffectedPacket: policyPacket.proofArtifact.digest === unchangedPolicy.proofArtifact.digest,
    changedReviewer: changedReviewer.kind,
    effectfulRefused: true,
  }));
} finally {
  await rm(directory, { recursive: true, force: true });
}

Next steps

A file change approved byte for byte: an approval bound to exact output bytes, with a backup and a readback.
Callback gates: the stored client and the request identity an approval rides on.
Workspace: capturing and verifying the anchor a result is bound to.

Start

Concepts

Patterns

Examples

Evals and Gates

Recording Runs

Driving Runs

Surfaces and Hosts

Writing Workflow Shapes

Memory

Workspace

Compare

FAQ

API Reference

Decisions Bound to Bytes

Accept a result

Bind an approval

Resolve before you act

Failure

Limits

Next steps

​Accept a result

​Bind an approval

​Resolve before you act

​Share evidence

​Failure

​Limits

​Next steps

Accept a result

Bind an approval

Resolve before you act

Share evidence

Failure

Limits

Next steps