ProofPack Release Gate

GPT-5.6 proposes. ProofPack proves—or rejects. Contradictory documents stay on HOLD instead of becoming fabricated mistakes.

Comment

Inspiration

GPT-5.6 proposes. ProofPack proves—or rejects. Contradictory documents stay on HOLD instead of becoming fabricated mistakes.

ProofPack is a pattern for any AI-era handoff where evidence must outrank confidence: AI proposes candidate bindings, deterministic rules judge admissibility, and humans keep release authority. Millwork fabrication is my proving ground because it is the industry where I have watched document contradictions become expensive physical mistakes.

See the one-page ProofPack Pattern · Run the 90-second judge path In my day-to-day drafting work, a millwork shop often sends me its proposal and the architectural set. I draw the millwork to the proposal because that is what the shop estimated and charged for. But the architect has the final say, and what is signed off in the architectural set is usually what must actually be fabricated. When those sources contradict each other, a PM or estimator coordination error can send my drawings—and eventually the shop—in the wrong direction.

That is the problem behind ProofPack. I wanted a tool that makes the contradiction visible, shows exactly which source supports each claim, and stops the handoff before a drafting mismatch becomes physical work.

Every file in this demo is synthetic. ProofPack does not ingest or expose client data.

What it does

ProofPack Release Gate is a bounded evidence compiler for safer handoffs. It compiles raw-ish Markdown, JSON, and log fixtures through explicit packet rules into normalized observations, five transparent claim states—VERIFIED, INFERRED, NEEDS_CONFIRMATION, CONFLICTED, and BLOCKED—an evidence ledger, and a separate HOLD or READY fabrication decision.

The fictional Project Alder packet starts on HOLD: PL-17 and PL-18 conflict, the current traveler has not acknowledged RFI-042, and the finish sample is pending.

A real, schema-bound GPT-5.6 Sol run proposes three candidate evidence bindings from a synthetic operator email. ProofPack independently reviews them. Two exact traveler bindings are ADMISSIBLE; the estimator's claim that the sample “looks approved” is REJECTED / UNAUTHORIZED_AUTHORITY. A judge can explicitly apply the admitted pair and watch exactly two causal claims change. The sample blocker remains, so fabrication stays blocked and the handoff stays on HOLD. Reset recompiles the original packet and restores its original SHA-256 receipt.

ProofPack also exports a full internal operator handoff and a separately constructed, typed allowlisted public-safe Markdown artifact. A human may acknowledge the HOLD or document an exception request, but neither action rewrites evidence or clears a blocker.

How I built it

One pure TypeScript core validates a closed packet and finite ruleset, normalizes Unicode, line endings, timestamps, and declared nonsemantic ordering, resolves exact line/JSON Pointer/log anchors, derives observations, classifies claims, and builds the handoff. The CLI and React interface call the same core.

The grammar is intentionally narrow: exact text-line checks, exact predeclared log events, JSON Pointer equality or presence, four fixed claim kinds, named dependencies, and a local authority resolver for mutually exclusive values. ProofPack is not trying to “magically understand any document.” It demonstrates a safer pattern for AI-era work: constrain the packet, preserve evidence anchors, classify claims transparently, and export a handoff humans can verify.

GPT-5.6 Sol also powers one optional developer command, npm run ai:propose. It runs through a pinned Codex CLI with a read-only sandbox, ephemeral session, closed output schema, prompt over stdin, and no fallback model. The model can propose exact bindings, but it cannot assign status, declare authority, change rules, clear blockers, or decide READY. The deterministic reviewer and a human application step remain the authority.

The default submitted app, compiler, demo, and tests are fully local and deterministic. They require no OpenAI API key, Codex login, or network access. This submission ships with its own canonical repository receipt: 2e34b4ad66f0e05fe09c79d8042e422ea724072681c1fe9d8dc5dadf86692703, with the self-reference normalization documented in the repository.

How I used GPT-5.6 and Codex

I used Codex and GPT-5.6 Sol throughout the build to challenge the product idea, sharpen the real millwork workflow, design the status semantics, implement the compiler and interface, write tests, and adversarially review the safety boundaries.

The optional proposal workflow is also a real GPT-5.6 Sol use—not a prewritten fake response. Its checked-in run record is sanitized, labeled untrusted and non-authoritative, and SHA-256 linked to the exact request, proposal, packet, execution policy, and deterministic review for reproducible comparison—not signature or model-identity attestation.

Primary Codex /feedback session: 019f813e-8569-7d32-bdbc-cc1b2cf829f7.

Challenges

  • Keeping outputs byte-stable across source order, Unicode normalization, line endings, timestamp offsets, and repeated runs without wall-clock time or randomness.
  • Separating epistemic status from operational release so one favorable receipt cannot turn an unrelated gate green.
  • Preserving exact source lineage while building a public-safe artifact from a typed allowlist instead of pretending broad text redaction is enough.
  • Preventing favorable AI wording from becoming authority: unknown tool activity, stale targets, invented lines, malformed output, and unauthorized sample approval all fail closed.
  • Making live recomputation visibly falsifiable: application changes exactly two claims, and reset restores the original fingerprint.

Try to make it go READY

The fail-closed challenge replays unauthorized approval, an invented line, and a stale packet target. Every manipulation is rejected, and the handoff remains on HOLD.

Accomplishments

I am proud that this is a complete source-to-decision chain, not a mock dashboard. It preserves exact evidence lineage, detects contradictions, rejects unauthorized model suggestions, produces causal before/after diffs, keeps independent blockers intact, and creates separate internal and public-safe artifacts.

The final release gate passes 163 TypeScript tests, 21 privacy-scanner tests, and 3 rendered-product tests, plus lint, typecheck, production build, CLI demo, privacy scan, and local and hosted browser smoke tests.

What I learned

The biggest lesson was that AI assistance does not require surrendering authority to a model. GPT-5.6 can help find candidate evidence while deterministic rules decide what is admissible and humans remain responsible for release.

I was surprised by how quickly this came together, how good the result became in a short build, and how clear the AI voiceover sounds in the video. More personally, I am proud to be learning AI while managing my business and already implementing it in my day-to-day work.

I also learned that public sharing is safer as a typed projection problem—not a find-and-replace problem.

What's next

I would add carefully validated rule packs and packet-authoring tools before considering OCR, arbitrary uploads, integrations, or real data. Those expansions need their own validation and privacy boundaries; the Build Week version stays intentionally bounded.

Built With

Share this project:

Updates