<!-- SOLIDIVISM · part 30 -->
es
5. Run verification tests T1-T10 + T-F1 through T-F6
6. Deploy to live (`/solidivism/`) — separate authorization after staging verification

**No action taken until authorized.**

---

---

## THREE FINAL DISTINCTIONS (GPT-6 Controlled Authorization)

### Distinction 1: Confidence Reflects Evidence Quality, Not Count

Confidence must reflect evidence quality, independence, relevance, and contradictions — not merely the number of supporting records.

**Revised confidence assessment:**

```javascript
function assessConfidence(evidence) {
  // Quality: what type of evidence?
  // - Direct observation (screenshot, console log): high quality
  // - Code inspection (static analysis): medium quality
  // - Inference from correlation: low quality
  // - Hearsay / relayed report: low quality

  // Independence: do multiple pieces share a common source?
  // - 3 screenshots from same browser session: NOT independent (count as 1)
  // - Browser test + iPhone screenshot + code inspection: independent (count as 3)

  // Relevance: does the evidence actually address the claim?
  // - "Buildings visible" screenshot is relevant to "rendering works"
  // - "Buildings visible" screenshot is NOT relevant to "collision works"

  // Contradictions: does any evidence oppose the claim?
  // - ANY contradiction caps confidence at "medium" maximum
  // - UNRESOLVED contradiction caps at "low"

  let score = 0;
  const independentSources = new Set();

  for (const e of evidence) {
    if (!e.relevant) continue;  // Irrelevant evidence contributes nothing
    if (independentSources.has(e.sourceId)) continue;  // Not independent

    independentSources.add(e.sourceId);
    if (e.quality === 'direct') score += 3;
    else if (e.quality === 'inspection') score += 2;
    else if (e.quality === 'inference') score += 1;
    // hearsay: 0
  }

  const contradictions = evidence.filter(e => e.contradicts);
  const unresolved = contradictions.filter(c => !c.resolved);

  if (unresolved.length > 0) return 'low';
  if (contradictions.length > 0 && score >= 6) return 'medium';  // capped
  if (score >= 6) return 'high';
  if (score >= 3) return 'medium';
  if (score >= 1) return 'low';
  return 'unknown';
}
```

**Example:** 10 browser screenshots from the same test session showing buildings visible = 1 independent source, direct quality = score 3 = "medium", NOT "high". To reach "high", need independent confirmation (e.g., iPhone screenshot + code inspection showing no render-blocking errors).

### Distinction 2: Checksums Are Integrity Checks, Not Anti-Tampering Guarantees

Checksums detect accidental corruption (bit rot, transmission errors, bugs). They do not prevent intentional tampering by someone with database access.

**Honest description:**

```javascript
// What checksums DO:
// - Detect accidental corruption during storage/transmission
// - Detect application bugs that modify data unexpectedly
// - Provide evidence that a record hasn't changed since written

// What checksums DO NOT:
// - Prevent a database admin from modifying a record and recomputing the checksum
// - Prevent tampering at the database level
// - Guarantee the original data was truthful (garbage in, checksummed garbage out)

// True tamper-evidence would require:
// - Write-once storage media, OR
// - Cryptographic signatures with keys the app doesn't hold, OR
// - External anchoring (blockchain, timestamping service)
// None implemented in Phase 1. Documented as limitation.
```

**Revised schema comment:**
```sql
-- checksum: SHA256 integrity check
-- PURPOSE: Detect accidental corruption, not prevent intentional tampering.
-- A database superuser can modify records and recompute checksums.
-- For Phase 1, we rely on: restricted roles, audit logging (pgAudit),
-- and the King's trust in server administration.
-- Tamper-evidence via external anchoring deferred to future phase.
```

### Distinction 3: Observable Health Without Interference

Observation failures must never interfere with the 3D world, but must remain diagnosable through a separate health mechanism.

**Implementation:**

```javascript
// In Epistemology module (NOT in 3D code)
const Health = {
  observations: { attempted: 0, succeeded: 0, failed: 0 },
  lastError: null,
  lastSuccess: null,

  recordAttempt() { this.observations.attempted++; },
  recordSuccess() {
    this.observations.succeeded++;
    this.lastSuccess = new Date().toISOString();
  },
  recordFailure(error) {
    this.observations.failed++;
    this.lastError = {
      time: new Date().toISOString(),
      message: error.message,
      // Never throw. Never propagate to 3D.
    };
  },

  // Separate health endpoint (does not touch 3D)
  report() {
    return {
      observations: this.observations,
      lastError: this.lastError,
      lastSuccess: this.lastSuccess,
      syncQueue: localStorage.getItem('solidivism.epistemology.pending')?.length || 0,
      database: 'unknown',  // updated by periodi