ProcessProof

Inspiration

A serious project rarely lives in one Codex task. Developers and engineers open separate tasks for architecture, implementation, validation, documentation, and troubleshooting. Each task can be locally correct while the project loses its shared decisions, blockers, dependencies, and lessons. Valuable reasoning then disappears into chat history or is reduced to a generic end-of-project summary.

ProcessProof was built to give a project a memory larger than one chat task—and to turn only verified, reusable experience into an Agent Skill.

What it does

ProcessProof is a local-first Codex companion and developer tool. It treats the repository as the project identity and each Codex task as one workstream.

Each active task can publish one structured daily ThreadReceipt containing:

• its objective and resulting state;
• decisions and conflicts;
• validation evidence;
• blockers and dependencies;
• risks, open questions, and next actions.

Receipts contain structured conclusions rather than raw chat. ProcessProof joins same-day receipts into a daily rollup, then builds a cross-day project panorama for every new task to read. Missing task receipts remain visible as coverage gaps, and conflicting decisions remain attributed to their sources instead of being silently merged.

When GPT-5.6 recognizes a meaningful transition—a goal change, user correction, rejected approach, validated method, acceptance event, or safety-boundary change—it records a structured ProgressEvent explaining what changed, why it mattered, what evidence supports it, and whether it is project-only or reusable.

ProcessProof can then:

1. discover prioritized project summaries and decision records;
2. harvest project evidence with hashes and redacted excerpts;
3. connect reusable lessons to ProgressEvent and artifact IDs;
4. score a candidate Agent Skill;
5. require explicit human review;
6. compile a draft Skill with provenance;
7. validate its structure and safety boundaries; and
8. allow promotion only after a different-project forward test.

How we built it

The architecture deliberately separates semantic judgment from deterministic controls.

Codex and GPT-5.6 read the project panorama, prioritized summaries, current-task context, and evidence. They explain why a progression matters, reconcile cross-task context, surface uncertainty, and propose reusable workflows.

Local Python handles deterministic operations: project initialization, Codex Hook observations, receipt upserts, daily and cross-day aggregation, schema validation, IDs, deduplication, hashes, redaction, approval state, Skill compilation, static validation, and lifecycle gates.

Humans retain authority over reusable knowledge, high-risk engineering rules, and final promotion.

ProcessProof installs project-local Codex configuration with processproof codex-init. It adds a bounded block to AGENTS.md, installs a repo-local Skill, creates project-local lifecycle Hooks, and snapshots a private runtime without changing global Codex settings.

The Build Week development record shows the product evolving through three verified increments:

• v0.2.0: evidence harvesting, redaction, candidate scoring, human review, Skill compilation, validation, and promotion gates;
• v0.3.0: project-level Codex setup, lifecycle observations, prioritized summary discovery, semantic ProgressEvent records, and event-grounded provenance;
• v0.4.0: daily per-task receipts, same-day rollups, cross-day project panorama, context injection, coverage gaps, blockers, dependencies, decisions, and next-action ledgers.

Codex accelerated the package architecture, implementation, tests, documentation, and cold-path validation. The defining product and safety decisions remained human decisions: the meaning of progress is the core object, project summaries are authoritative inputs, project-local configuration comes first, and unverified or high-risk knowledge cannot silently become policy.

Runnable demo

The public MIT-licensed repository includes a deterministic synthetic demo. It requires Python 3.11+ and Git, but no API key or proprietary engineering software.

py -X utf8 scripts/run_demo.py D:\Temp\processproof-demo

The current v0.4.0 verification passes all 14 tests. The demo discovers a project summary, harvests 3 evidence records, registers a semantic progress event, records 2 task receipts across 2 directions, generates the daily rollup and project panorama, compiles a Skill, and returns validation.valid: true with no validation errors.

Challenges we ran into

The hardest problem was not summarization; it was defining trustworthy project knowledge across tasks.

• Codex Hooks can observe lifecycle events but cannot determine whether an experience is reusable.
• A current task cannot silently assume that it contains the full project truth.
• Missing receipts and conflicting decisions must remain visible.
• File changes and model summaries are evidence inputs, not automatic approval.
• Sensitive paths, credentials, project identifiers, and proprietary terms must not leak into generated Skills.
• A Skill that works only in its source project is not yet reusable.

These constraints led to the separation between observation, semantic interpretation, deterministic evidence, human approval, and independent-project validation.

Accomplishments that we're proud of

ProcessProof now provides an end-to-end, runnable path from fragmented multi-task work to a source-linked project panorama and a validated draft Agent Skill.

We are especially proud that the system:

• preserves disagreement instead of inventing consensus;
• exposes missing-task coverage explicitly;
• reads the work summaries users already maintain;
• records why a progression mattered, not just which files changed;
• keeps raw chat out of daily receipts;
• redacts sensitive evidence before reuse;
• requires human acceptance and a forward test before activation;
• runs locally with a dependency-free Python core.

What we learned

Useful project memory is not a transcript and not a diff. Its smallest valuable unit is a verified transition: the prior goal, the action taken, the resulting state, why the change mattered, the supporting evidence, and the boundary of reuse.

GPT-5.6 is strongest at interpreting those transitions and relationships. Deterministic code is strongest at enforcing schemas, hashes, redaction, aggregation, and lifecycle gates. Human review is essential wherever reuse, safety, or professional judgment is involved.

What's next

Next, we plan to:

• streamline task discovery and receipt creation in the Codex app;
• add a non-technical project-panorama interface;
• support richer import of completed-task summaries without copying raw chat;
• improve duplicate and contradiction detection across longer projects;
• add more independent-project forward-test fixtures;
• package installation and judge testing into an even shorter guided flow.

ProcessProof does not claim that model output is automatically true. It provides a traceable path for turning meaningful, evidenced, human-reviewed project experience into reusable capability.

Built With

• codex
• codex-hooks
• git
• gpt-5.6
• pytest
• python-3.11