popcorn-temporal-anchor

# 767-2676.com — signed task schedule checkpoints for agents

**Licensing:** [component boundaries and earlier grants](LICENSING.md) · [evaluation terms](LICENSE.md) · [receipt carry-and-use permission](docs/RECEIPT_USE.md). The paid service is separate from code permissions.

## Run the verification checks yourself

[Offline checker and instructions](examples/verification-checks/README.md): 37 cases covering schedule boundaries, malformed input, exact bytes, and saved signed receipts. From this repository with Node.js 20+:

```sh
node examples/verification-checks/check.mjs
```

No wallet, payment, or network call. Expected results are separate from computation. These checks establish code behavior and historical verification, not live authorization or execution.


Searching for **RFC 3161**, **OpenTimestamps**, a **trusted timestamp**, or
**proof of existence** before an **authorization expiry**? Start with
[Proving an action happened before an authorization expired](https://767-2676.com/prove-action-before-authorization-expired)
([source](docs/proving-action-before-authorization-expired.md)). Run its free
receipt-chain verifier first, then follow the pre-action check and post-commit
binding. Evidence explains a decision; it does not grant permission.

## Here, try your free sample

[Can I still cancel? Which side of the deadline am I on?](https://767-2676.com/schedule/example)

Inspect the page. Save and read [sample.mjs](https://767-2676.com/schedule/sample.mjs), then run `node sample.mjs` with Node.js 20 or newer. No key, wallet, or payment for this offline sample.

Expected results: `verified: true`, `digest_matches: true`, and `one_byte_who_tamper_rejected: true`. This is a 305-byte task schedule with historical evidence; it does not establish current time or authorization.

[Agent instructions](https://767-2676.com/skills/task-time/SKILL.md) · [Take the packet home](https://767-2676.com/schedule/example.json) · [Hugging Face](https://huggingface.co/spaces/violetclaire/767-2676.com)

The older 228-byte checkpoint example below is a separate demonstration.


POPCORN is Briarwood AI's service for signed time and digest witnesses. Use it
when independent agents need timing evidence for a deadline, a handoff, or one
exact task version. Each participant retains its raw task data and decisions.

> A note is not a check. These 228 bytes are.

Start with the settled public packet. It lets a human or agent verify the
signature, compare the signed witness interval with the execution window, and
prove that one changed byte breaks the digest. It is free, offline, and requires
no wallet.

POPCORN also operates a live, machine-payable temporal evidence service at
[`767-2676.com`](https://767-2676.com). A wallet-enabled agent can pay `$0.001`
USDC over x402 v2 for a new signed temporal receipt when a later live task
actually needs fresh evidence.

The live node also provides the tested
`POPCORN-WITNESS/1.0` contract for a payload-bound checkpoint: a lightweight
way for an autonomous agent to carry **portable, verifiable evidence that one
exact task-state commitment reached an external witness** without putting its
private task state in a shared database. That additive endpoint is deployed,
paid through x402 on Base mainnet, and independently verified in both
JavaScript and Python.

The service is intentionally narrow. It provides evidence for participant-local
judgment; it does not schedule work, reserve resources, authorize actions, or
store an agent's private task state.

## Lab record

On 31 August 2026, Grok and Codex coordinated one live payment using only text I copied and pasted. The record documents the exact bytes, settlement, approval, and refusal.<br>
[Read the lab record and verify the packet.](https://767-2676.com/lab-record)

- **Production node:** `767-2676.com`
- **Paid resource:** `GET https://767-2676.com/v1/time`
- **Paid witness:** `POST https://767-2676.com/v1/receipt`
- **Payment:** `$0.001` USDC on Base mainnet (`eip155:8453`)
- **Protocol:** x402 v2, exact scheme
- **Receipt:** ES256 compact JWS with public JWKS verification

## Start here

The MCP connector includes a free evaluation of both historical production
receipts. To run it from this repository:

```bash
git clone https://github.com/violetclaire/popcorn-temporal-anchor.git
cd popcorn-temporal-anchor/packages/mcp
npm ci
npm run build
node dist/packages/mcp/src/index.js --sample
```

After version 0.1.3 is published to npm, the same evaluation is one command:

```bash
npx -y @violetclaire/popcorn-mcp@0.1.3 --sample
```

It verifies both bundled historical production receipts and rejects their
one-byte tamper controls. After installation, the evaluation is
fully local and needs no wallet. A connected MCP agent can call `popcorn_sample`
with `{}` for the same check. See the [connector guide](packages/mcp/README.md)
for installation and choosing a tool for deadlines, task versions, or handoffs.

Run the checked-in STOP packet before making any network or payment call:

```bash
node --disable-warning=ExperimentalWarning --experimental-strip-types examples/witness/verify-settled-sample.mjs
```

Expected result:

```text
cryptographic_verification=valid
schedule_overlap=false
local_policy_outcome=stop
error_code=witness_payload_digest_does_not_match_expected
```

The command imports the reusable TypeScript verifier, checks the exact 228-byte
schedule, applies the published one-byte mutation at offset 226, and exits zero
only when the valid packet and failed digest control both behave as expected.
It does not call `767-2676.com` or any payment endpoint.

Open the human version at [`/demo`](https://767-2676.com/demo). Its publish-ready
source is in [`site/demo`](site/demo), and the deployment handoff is in
[`OPERATOR.md`](OPERATOR.md).

Agents can install the same sample-first instructions from either desk:

```bash
openclaw skills install @violetclaire/popcorn-temporal-anchor
npx skills add violetclaire/popcorn-temporal-anchor --skill popcorn-temporal-anchor
```

The public machine door remains
[`https://767-2676.com/SKILL.md`](https://767-2676.com/SKILL.md).

## Available service

| Service | Use when | Method and resource | Price | Returns | Storage |
| --- | --- | --- | --- | --- | --- |
| Signed portable time | A task has a deadline, expiration, execution window, or handoff | `GET https://767-2676.com/v1/time` | `$0.001` USDC on Base through x402 v2 | Signed time another system can verify | The task and schedule stay with the agent |
| Paid schedule checkpoint | An agent needs portable evidence that one exact schedule or task digest was presented at a particular time | `POST https://767-2676.com/v1/receipt` | `$0.001` USDC on Base through x402 v2 | Signed digest commitment another system can verify | The raw task and schedule stay with the agent |

POPCORN says what time it is. The agent carries that measurement in its own
schedule. POPCORN does not store the task or schedule and does not decide what
happens next.

## Portable, verifiable state checkpoints

> Your agent already carries task state. What it lacks is portable evidence
> that one exact version reached an external witness within a stated time
> window.

The live paid resource is:

```text
POST https://767-2676.com/v1/receipt
```

The agent hashes the exact payload bytes locally and sends only:

- the SHA-256 payload digest;
- a fresh 32-byte nonce;
- optionally, the SHA-256 digest of the preceding receipt's exact signed payload bytes.

POPCORN signs those values with a bounded witness interval. The agent carries
the original payload and signed evidence together. A later session or another
system can verify that the payload has not changed, when the node witnessed its
commitment, and whether the evidence commits to a specific predecessor.

The receipt alone is not memory: it cannot reconstruct, retrieve, understand,
or act on the payload. It also does not prove caller identity, recipient
delivery, action execution, replay prevention, or authorization. Read the full
[`POPCORN-WITNESS/1.0` contract](docs/WITNESS_RECEIPT.md).

### Verify two settled production outcomes

The original checked-in [`evaluation-packet.production.json`](examples/witness/evaluation-packet.production.json)
remains unchanged. Its cryptographic verification succeeds, but its checkpoint
falls after the schedule closed, so the example consumer policy says **STOP**.
The companion [`evaluation-packet.proceed-002.production.json`](examples/witness/evaluation-packet.proceed-002.production.json)
also verifies and rejects a one-byte tamper, while its checkpoint overlaps the
schedule window, so the example consumer policy says **PROCEED**. The
machine-readable [`evaluation-outcomes.json`](examples/witness/evaluation-outcomes.json)
states the local overlap rule and both expected decisions.

Each packet contains exact schedule bytes, a SHA-256 digest, nonce, settled
production response, public key, successful cryptographic result, and a
one-byte tamper case that must fail. They contain no private key, CDP
credential, wallet secret, reusable payment proof, or private customer data.
`evaluation_only: true` is outside the signed payload, so each production JWS
remains unchanged. POPCORN proves the checkpoint; the consumer applies its own
schedule policy and decides whether to proceed.

The reusable [`verify/typescript`](verify/typescript) and
[`verify/python`](verify/python) packages independently implement the witness
contract. The production packet records the reproduced success and one-byte
failure results, and the original deployment test logs remain outside this
public repository.

### Carry a schedule between two computers

The [`typescript-x402-witness-client`](examples/typescript-x402-witness-client)
now accepts an exact schedule file or HTTPS URL instead of inventing a built-in
example. It hashes the bytes, pays for the checkpoint, captures the x402
exchange, verifies the live POPCORN key, and writes a portable o