Finish Small App — Release Evidence Desk

Proof, not vibes, for small-app releases.

Comment

Inspiration

Independent developers routinely finish a build and accidentally describe the whole release as complete. But “the source exists,” “the build passed,” “the artifact installed,” “it launched,” “a human completed the journey,” and “the exact version is public” are six different facts.

That evidence gap becomes more dangerous when agents help with release work. An agent can summarize logs and record observations, but it cannot honestly claim that a person played a game, that a real device test happened, or that an external store accepted and published a version unless evidence for that exact boundary exists.

Release Evidence Desk turns that problem into a visible, shared workspace: proof, not vibes, for small-app releases.

What it does

A person creates a release project, records exact claims, attaches dated evidence, and sees evidence-derived verdicts across five tracks:

  • Source
  • Build
  • Install / Runtime
  • Human Play
  • External Release

The desk separates six release boundaries, highlights contradictions, quarantines unreviewed observations, exposes concrete gaps, generates an ordered verification plan, and exports a privacy-scrubbed handoff.

The built-in anonymous demo is intentionally blocked. It has confirmed Source and Build proof, an install note awaiting human review, no confirmed Runtime proof, a contradicted Human Play claim, and no verified External Release status. That honest “2 of 6” is the product’s point.

Why WebMCP is essential

The most useful context is already in the live page: the active release candidate, exact claim IDs, confirmed evidence, pending review, contradictions, and gaps. A separate chatbot would duplicate or drift from that state. Screen automation would have to infer meaning from visual cards.

WebMCP gives the agent a precise contract over the same live page the human is using. A real workflow can run in sequence:

  1. Read the current snapshot.
  2. Audit every release claim.
  3. List the missing evidence.
  4. Generate an ordered release plan.
  5. Record a human-supplied observation.
  6. Export a sanitized handoff.

Every state-changing result is immediately visible in the interface and operation log.

The write path is deliberately asymmetric. Agent-proposed supporting evidence is always marked pending human review, so it can appear in the UI without upgrading a claim. Contradictions may reduce confidence immediately. Only a human can confirm supporting evidence. WebMCP is therefore not a decorative integration—it is the trust boundary for the product.

Human–agent collaboration

  • The human identifies the exact project, target, and release candidate.
  • The agent reads current claim IDs and coverage from the page.
  • The agent separates supported, contradicted, pending, and unknown statements.
  • The agent plans the next checks with explicit developer, tester, and release-owner responsibilities.
  • When the human supplies a new observation, the agent records it and the page updates live.
  • The human confirms or rejects proposed supporting proof.
  • Either side can generate a privacy-safe Markdown or JSON handoff without turning unperformed work into a Pass.

How we built it

The page uses the real WebMCP imperative API and registers six tools with document.modelContext.registerTool(...). Every tool has an exact name, bounded description, strict JSON Schema, additionalProperties disabled, independent runtime validation, corrective errors, annotations, and structured observable output.

  • get_project_snapshot — active project, revision, coverage, evidence tracks, and claim IDs.
  • list_missing_evidence — missing claims, proof gaps, contradictions, and pending review.
  • audit_release_claims — evidence-derived claim verdicts.
  • add_evidence_item — validated live-state mutation with a human-review quarantine.
  • generate_release_plan — ordered verification actions derived from current gaps.
  • export_sanitized_handoff — Markdown or JSON with emails, secrets, private paths, and private URLs scrubbed.

React renders the control-room interface. TypeScript owns the proof model and tool contracts. Versioned localStorage keeps projects local-first and reload-safe. Vitest and Playwright test the state invariants, error contracts, keyboard flows, persistence, and responsive UI. Vercel hosts a static production build with no account, backend, paid API, telemetry, or runtime network dependency.

Challenges

The hardest problem was not registering tools. It was preventing a convenient write tool from becoming a confidence-escalation shortcut.

We separated claims from evidence-derived verdicts, separated Install from Runtime within one visual lane, introduced a human-review state for supporting agent observations, and made verdicts pure functions of confirmed evidence. We also created corrective errors for wrong claim IDs, mismatched evidence types, unsupported bounds, and unsafe handoff requests.

A second challenge was keeping browser capability claims honest. Ordinary CI Chromium uses a small registration harness to exercise production contracts. Native WebMCP was verified separately in ChatGPT’s in-app browser and in flag-enabled Chrome 151 and 152. The public demo records the actual native getTools() and executeTool(...) workflow. Those proof layers remain explicitly separate.

Accomplishments

  • A coherent five-track, six-boundary release evidence model.
  • Six non-trivial WebMCP tools supporting a complete multi-tool workflow.
  • Agent write → visible UI update → pending human review → reload persistence.
  • Empty projects remain 0/6 and incomplete; missing state never becomes a Pass.
  • Positive, invalid-input, empty-data, and state-sync cases for every tool.
  • Responsive desktop and mobile layouts with keyboard access.
  • Privacy-scrubbed Markdown and structured JSON handoffs.
  • A public, audible 2:02 demo showing native discovery, audit, planning, guarded write, persistence, empty-state protection, handoff, and the prior-work boundary.

What we learned

Agent-ready does not mean agent-controlled. The best collaboration surface gives an agent precise affordances while preserving human authority over evidence the agent cannot physically observe. WebMCP makes that separation explicit in the tool contract, state model, and interface.

Prior work disclosure

The problem framing was informed by the entrant’s earlier public MIT-licensed project, Culaliya/finish-small-app-v1. That repository remains a read-only conceptual source and is not this submission.

Release Evidence Desk is a clean, independent web application created after the WebMCP Challenge opened. Its UI, data model, state engine, WebMCP implementation, tests, visual assets, documentation, and Git history are new. No source code, assets, or Git history were copied from the earlier project, and the earlier project was not converted into an MCP server.

What is next

The submitted version will remain frozen throughout judging. A future separate fork could add import adapters for common CI receipts, signed evidence bundles, team review roles, and shareable read-only snapshots while preserving the same evidence boundary.

Try it

Built With

Share this project:

Updates