Approval is not payment. Delivery needs evidence.
Reviewed test plans, payment-lifecycle fault scenarios and inspectable results in one developer tool.
Built for the PayPal AI Hackathon 2026
Payment lifecycle diagnostics · By Desan Vasu
Features · Demo · Watch video · Get started · DeepSeek & execution · Documentation
Actual terminal capture · corrected recorded run · simulated payment provider.
A checkout can look successful while delivery is wrong. Approval might unlock a download before capture, repeated processing might grant access twice, or a successful capture with a lost response might leave the application uncertain.
PayProbe turns a digital-purchase requirement into a reviewed scenario plan. A deterministic runner compares application delivery with a separately recorded simulated payment ledger, retains observations and makes each finding inspectable. DeepSeek helps plan and explain; evidence and deterministic checks determine the verdicts.
Current scope: a working local CLI and browser prototype with simulated payments and real DeepSeek API use. Actual PayPal API integration and sandbox verification remain deferred. The submitted PayPal AI Hackathon 2026 entry discloses that boundary.
|
Generate a bounded scenario plan, inspect the saved draft and explicitly accept it. Execution is bound to that reviewed source. |
Check approval without capture, matching capture and delivery, sequential repeat processing, and reconciliation after a suppressed capture response. |
|
Keep PASS, FAIL, INCONCLUSIVE, UNSUPPORTED and ERROR distinct. Missing evidence and an explanation failure cannot manufacture a successful payment check. |
SQLite retains reviewed plans, operations, observations and run state. Resume the existing case instead of silently replanning or starting a replacement run. |
|
Select a scenario, filter results and open the recorded evidence in the graphite/amber/ivory/plum terminal interface. Inspection performs no payment operations. |
Follow the plan, review, simulated approval and result workflow in a local browser. Export text/JSON and request an optional evidence-referenced explanation. |
Watch the narrated 2:50 walkthrough on YouTube → · Submitted project · Download the source release
- Inspect a real DeepSeek-generated plan and explicitly review it.
- Run the controlled sample workflow, pause for simulated approval and resume the same case.
- Inspect a seeded duplicate-delivery failure: one capture, two entitlements.
- Compare a separate corrected run and inspect lost-response reconciliation evidence.
- Watch an actual DeepSeek request, its complete wait and returned explanation, then export the recorded report.
A visible failure. An intentionally faulty sample store grants two entitlements after one capture. |
The evidence behind the result. Compare simulated provider capture with application delivery observations. |
A browser workflow too. Local planning, review, approval and reports. Inspect the recorded fixture results → |
Real AI, referenced evidence. Readable inspection of the just-returned response; deterministic verdicts remain unchanged. |
Capture provenance and attribution →
You need Node.js 24.14+ within the 24.x line, npm and a terminal. A private DeepSeek API key with available credit is needed for fresh planning and explanations. Payments are simulated; no PayPal account or credentials are required for this release.
Clone the repository or extract the packaged source, then run:
git clone https://github.com/desanv01/PayProbe.git
cd PayProbe
npm ci
npm run build
npm start -- doctordoctor creates .env.local from the blank template only if absent. Set DEEPSEEK_API_KEY there; preserve an existing configuration. Leave PayPal fields blank. Defaults are deepseek-flash and the simulated provider. Credentials stay local and ignored by Git.
npm start -- serveKeep the server running and open http://127.0.0.1:4310/demo on the same computer. This is a local application; no public live-demo service or judge key is supplied.
In a second terminal at the same project root, with the same configuration:
New-Item -ItemType Directory -Force .private/demo | Out-Null
npm start -- plan examples/download-contract.json --out .private/demo/draft-plan.json
Get-Content .private/demo/draft-plan.json
# Accept only after inspecting the exact saved draft:
npm start -- plan --review .private/demo/draft-plan.json --out .private/demo/reviewed-plan.json
npm start -- run .private/demo/reviewed-plan.json --auto-approve-simulatedThe first plan command calls DeepSeek. Review and execution make no new AI request. The approval flag authorizes simulated orders only; omit it to pause for approval. Use fresh output filenames for another attempt—existing plan/explanation files are never overwritten.
Use the actual run ID returned by execution:
$runId = 'PASTE_ACTUAL_RUN_ID'
npm start -- ledger $runId
npm start -- report $runId --format text
npm start -- report $runId --format json
# Optional fresh DeepSeek request:
npm start -- explain $runId --out .private/demo/explanation.json
# Continue an existing paused or interrupted run:
npm start -- resume $runId --auto-approve-simulatedUse arrows or j/k to select, Enter for evidence, / to filter and q to leave the ledger. Non-interactive terminals receive plain text. Keep the SQLite directory for recovery; browser sessions expire after a server restart while recorded runs persist. Node's experimental SQLite warning is expected.
Complete setup and configuration → · Judge walkthrough →
DeepSeek maps a requirement onto supported scenarios through a bounded, schema-validated JSON interface. The saved plan requires explicit review; an unreviewed or modified plan cannot run. The explainer receives recorded evidence and must cite valid references. It does not decide or change deterministic verdicts.
The openai npm package is compatible transport with an explicit DeepSeek endpoint and key. No OpenAI runtime account or key is needed. deepseek-flash is a rolling alias for the requested V4.1-Flash-1017 model; an immutable provider snapshot is not claimed.
Review, run, resume, ledger and report commands require no fresh model call. Planning and explanation can consume API credit. The repository ships no private key, database or accepted private run. AI workflow implementation →
| Check | Boundary | Observed demonstration |
|---|---|---|
| S1 | Approval before capture | Simulated approval does not grant delivery |
| S2 | Capture and fulfillment | Matching completed capture yields one accessible entitlement |
| S3 | Repeated processing | Corrected run preserves one entitlement across three sequential calls; faulty sample shows two and FAIL |
| S4 | Lost capture response | Existing simulated capture is reconciled and delivery occurs once |
A reviewed real-DeepSeek/simulator journey completed all four checks with 42 evidence events. The film's faulty, corrected and pause/resume takes are separate runs; their identifiers and counts must not be combined. These are observations of our controlled sample, not third-party vulnerability findings or a production qualification.
Focused checks covered process restart, reviewed-plan persistence, duplicate delivery, wrong amount/currency, missing evidence, redaction, terminal/browser interaction and clean setup. Source CI runs the foundation, runner, AI workflow, stabilization and UI checks. Acceptance matrix →
| Interfaces | Application & validation | Persistence & recovery | Model access |
|---|---|---|---|
| Commander CLI · terminal ledger · local browser | Node.js 24 · TypeScript · Fastify · Zod | SQLite · persisted runs, reviewed plans and evidence | Official DeepSeek API · compatible SDK transport |
The simulated prerelease packages verified runtime source; newer repository commits add the video and presentation documentation. Source archive verification →
flowchart TB
subgraph Planning[Plan and review]
direction LR
A[Purchase requirement] --> B[DeepSeek draft]
B --> C[Human review]
end
C --> D[Deterministic runner]
D --> E[Sample app and delivery]
D --> F[Simulated payment ledger]
E --> G[Persisted evidence]
F --> G
G --> H[Deterministic verdicts]
H --> I[CLI and browser reports]
G --> J[DeepSeek explanation with references]
J --> I
The application and payment observations use separate paths inside one backend. This is a testable simulation boundary, not independent third-party payment verification. Runner · HTTP adapter · Sample store · Storage
Built solo by Desan Vasu for PayPal AI Hackathon 2026 and submitted on Devpost. The contribution is the reviewed planning/execution workflow, controlled payment-fault sample, persisted evidence/recovery and inspectable terminal/browser reports. Codex assisted implementation and debugging. Contribution and attribution record →
Current scope is a controlled digital-download target, USD integer cents, one full capture and sequential repeat checks. Actual PayPal integration, refunds, subscriptions, webhooks, concurrent-race coverage, arbitrary merchants and production/security certification remain outside this release. The receipt confirms submission, not organizer eligibility or an award. Submission receipt →
Repository presentation and terminal direction draw inspiration from FollowThrough; the HyperFrames film follows the owner's MajuPilot editorial direction. Actual PayProbe screenshots retain their approved palette. Media credits →
- Setup and configuration
- Judge walkthrough and no-key inspection
- Acceptance matrix and package verification
- Actual UI captures and connected browser checks
- Delivery checklist and video delivery
- Contributions and prior-work attribution
- Contribution guidelines and scope
Open an issue with reproducible steps, expected behavior and sanitized output. Keep keys, payment data and private documents out of public reports.
Original PayProbe code and documentation are MIT licensed. Dependencies, fonts, music and other third-party material retain their own rights and terms; see the contribution record and media credits.