Product Proof Status · GoingNinja Manual Knowledge Wiki

1. Current Status

Step	Status	Evidence
Provider baseline explained globally before bootstrap	`proven`	Before You Start and the updated planning path
Fresh repo bootstrapped from `goingninja-os`	`proven`	Global template generated a new product repo with the required state files
Product brief confirmed	`proven`	`PRODUCT_BRIEF.json`
Requirements confirmed	`proven`	`REQUIREMENTS.json`
Architecture requirements confirmed	`proven`	`ARCHITECTURE_REQUIREMENTS.json`
Readiness gate passed	`proven`	`READINESS_GATE.json`
Product-specific plan entered	`proven`	`PLAN.md`
Audit lane state can now be declared mechanically	`proven`	`AUDIT_STATE.json` in the global template and `docs/audits/AUDIT_STATE.json` in the manual repo
First public reading slice implemented locally	`proven`	`web/` routes `/`, `/why`, and `/today`; local checks and local preview verification
First public reading slice hosted on the intended deploy provider	`pending_live`	Global provider path is already proven; execution for the current Tagnova proof repo is the next bounded hosted step
Member save and archive slice implemented	`open`	Later bounded runtime slice
Protected operator update path implemented	`open`	Later bounded runtime slice
Launch proof complete	`open`	Depends on implementation, verification, and audit closure

2. What This Already Proves

The current Tagnova case already proves these global behaviors:

the provider baseline can be separated from product and architecture truth
the global repos can start a new product repo cleanly
product truth, requirements, and architecture can stay separate
planning can be blocked until a real readiness decision exists
the global system can be corrected first when the product exposes a contract gap

It does not yet prove the hosted Tagnova preview itself. That hosted execution is still the next concrete product-proof step.

3. Canonical Proof Snapshots

These shortened snippets are abridged extracts from the current proof repo state. They are useful because they mirror the live repo contract, not because they are decorative examples.

3.1 Confirmed Product Brief

{
  "status": "confirmed",
  "product": {
    "name": "Tagnova",
    "slug": "tagnova"
  },
  "planned_domains": [
    "tagnova.news",
    "www.tagnova.news",
    "www.preview.tagnova.news"
  ]
}

3.2 Confirmed Requirement Set

{
  "status": "confirmed",
  "functional_requirements": [
    "Provide a public landing page that explains the product clearly in one pass.",
    "Provide one public daily edition with separate sections for Vienna, Munich, and London."
  ],
  "preview_requirements": [
    "Before public launch, the current continuity state must be published on www.preview.tagnova.news."
  ],
  "access_requirements": [
    "www.preview.tagnova.news must stay behind Cloudflare Access before public launch."
  ]
}

3.3 Passed Readiness Gate

{
  "status": "pass",
  "ready_for_planning": true,
  "gate_checks": [
    {
      "id": "RG7",
      "name": "preview_and_access_contract_explicit",
      "status": "pass"
    }
  ]
}

3.4 Declared Audit State Shape

{
  "lanes": [
    {
      "id": "primary",
      "scope_class": "pending",
      "active_snapshot_ref": "pending",
      "current_mode": "pending"
    }
  ]
}

3.5 First Bounded Plan Shape

## Slice 1

- landing
- why Tagnova
- today's edition
- visible city split for Vienna, Munich, and London
- source-link contract
- calm mobile and desktop reading experience

4. Learnings Written Back

This proof case is useful only if its learnings become global rules.

The current writeback path is:

The major structural writebacks from this case are:

Requirements is now a required stage between Product Brief and Architecture Requirements
Readiness Gate is now a required stage before PLAN
AUDIT_STATE.json is now the mechanical audit-exit contract
the provider baseline is now explicit before bootstrap
the pre-launch hosted preview rule is now www.preview.<product-domain> behind Cloudflare Access

5. What Still Needs To Be Proven

Tagnova is not yet a full product proof. It still needs:

the first runtime slice on the intended hosted preview path
bounded verification for that hosted slice
bounded external audit closure for that slice
continuation through later slices
launch readiness for the actual product boundary

After Tagnova is functional on the corrected global contract, the next proof step is:

build a second new product through the same path
prove that the system works again without ad-hoc reconstruction

That second case will distinguish a one-off success from a repeatable platform.