Fast iteration. Slow claims. Reproducible evidence.

AI can explore grammar, architecture and tests at exceptional speed. TSCC turns that speed into engineering by bounding every checkpoint, separating evidence categories, retaining exact repository heads and requiring clean tools to reproduce the claimed result.

One checkpoint is a claim plus an evidence graph

A checkpoint is not “the agent edited some files and tests looked green.” It states one bounded observable contract, names the repositories and tools needed to prove it, records exact heads and requires every dependent evidence path to pass.

bounded claim
  ├─ focused compiler tests
  ├─ independent regression cases
  ├─ TypeScript oracle classification
  ├─ emitted-output inspection
  ├─ runtime execution where observable
  ├─ sanitizer / mutation / lifetime evidence
  └─ docs + handover reconciliation

The compiler, regression suite, JS++ runtime and websites are separate products and repositories. Their test relationship must be explicit. A sibling directory that happens to exist in one developer workspace is not a declared dependency.

Repository handovers preserve decisions, not truth by decree

Each repository carries a root HANDOVER.md. Deeper living documents record architecture, preview contracts, evidence, roadmap and history. They preserve why a boundary exists, which commands establish it, what remains unsupported and which repository owns each artifact.

Handovers are orientation maps, not scripture. Every developer or coding agent reconciles them against source, tests, Git history and observed behavior. When evidence changes the truth, source documentation and generated websites change in the same checkpoint.

The vertical-slice loop

state one compatibility contract
        ↓
classify it: syntax, emit, runtime, semantics or tooling
        ↓
query tsc / tsc --noCheck with pinned options
        ↓
add independent positive and negative cases
        ↓
implement every compiler stage the claim requires
        ↓
inspect output, diagnostics and ownership
        ↓
execute runtime-bearing fixtures
        ↓
stress scope, order, side effects and malformed neighbors
        ↓
run clean + sanitizer + aggregate gates
        ↓
reconcile performance, docs, handovers and roadmap

Evidence categories prevent false progress

This prevents a plausible AI patch from “implementing” a missing checker by rejecting legal grammar, or from calling a transform complete because the output merely parses.

The independent suite is an arbiter, not a percentage

The current compiler-agnostic corpus has 618 cases: 600 pass, zero current-scope failures and 18 intentional semantic skips. The frozen preview baseline remains 579 / 555 / 0 / 24. Neither ratio is a percentage of TypeScript completeness.

tsc --noCheck arbitrates syntax, full tsc identifies semantic-only differences and Node executes eligible output. The separate 7/7 Node/JS++ intersection requires explicit expected values and includes an anti-agreement self-test: two runtimes returning the same wrong answer still fail.

Promotion is how semantic support grows

A semantic skip becomes a pass only when TSCC owns that slice end to end with durable structure, positive acceptance/runtime cases, negative diagnostics and relevant neighbors. This process has grown from primitives into literals/unions, bounded narrowing, callable expressions, contextual callbacks, structural objects, index/call signatures, arrays, tuples and relative named-import type propagation while retaining 24 honest skips.

Reference behavior is queried deliberately

tsc --noCheck, full tsc, module mode, JSX mode, target and TypeScript version answer different questions. Fixtures pin enough context to make comparison meaningful. Oracle upgrades are classified across the suite rather than accepted one surprising case at a time.

Durable architecture must replace successful temporary paths

AI can extend a heuristic quickly enough that it appears permanent. TSCC’s checkpoint discipline instead asks when a temporary path should be retired. One production ProgramGraph replaced parallel file traversal; CompilationUnit retains per-file state; stable syntax/expression identity replaced repeated token rediscovery; the type-annotation parser was decomposed; and canonical types replaced ad-hoc facts.

Architecture checkpoints do not automatically increase language-support counts. That distinction is valuable: internal ownership work can be accepted for reducing future risk without being marketed as compatibility.

Clean-checkout reproducibility is part of correctness

The first post-preview GitHub run demonstrated why. Linux and macOS ran make test, whose preview validator expected a sibling suite that the workflow had not checked out. Both jobs therefore failed before compiler testing, while Windows passed its self-contained test-core target.

developer aggregate workspace
├── tscc/
└── tscc-regression-suite/   ← sibling happens to exist

isolated CI checkout
└── tscc/                    ← make test cannot find sibling

This is not evidence of a compiler defect, but it is an evidence-system defect. A serious multi-repository gate must declare and pin its topology. Valid approaches include checking out the sibling suite at a reviewed revision, consuming a versioned suite artifact, or keeping test-core self-contained while an explicitly provisioned aggregate workflow owns cross-repository validation.

TSCC commit bd7313c applies that rule: TSCC_REGRESSION_SUITE_DIR preserves the ordinary sibling layout locally, while Unix CI checks out exact suite revision c80d065 and exports its workspace path. Local validation covers both layouts. The repair remains evidence-pending until a pushed GitHub run completes successfully.

Candidate evidence must be reproducible, not narrated

TCP5 qualifies the bounded Linux preview with committed-archive builds, deterministic outputs and diagnostics, frozen positive/negative projects, both emit policies, ASan/UBSan, 400 deterministic mutations, a representative project, a loose startup guardrail and reproducible candidate archives. CP73 later completed the external Valgrind campaign on the Linux validation host and retained the exact commands/results in compiler evidence.

Unavailable evidence is recorded as unavailable. A tool that cannot start is not a product pass or fail. CP73 now demonstrates the required external-evidence pattern: exact repository head, platform/tool versions, commands, exit codes and leak/error summaries.

AI is useful in different roles

Why scope and side effects dominate strong tests

Compiler bugs hide behind easy literals. Cases use mutation counters, calls, getters, computed properties, short-circuiting, nested callbacks, parameter/block/catch/loop shadowing, re-exports and module cycles. Correct JavaScript must preserve evaluation count, order and binding identity - not merely parse.

Failure is evidence when classified honestly

An unsuccessful checkpoint can reveal that the proposed abstraction is premature, the oracle invocation is wrong, a fixture is invalid, a dependency is undeclared or the feature boundary is too broad. The response is not to bury the failure under more special cases. Minimize it, classify the responsible layer, update the plan and retain a permanent reproducer where it describes product behavior.

The post-preview phase changes the AI strategy

TCP0-TCP5 proved that the checkpoint method can reach a bounded compiler candidate. The next phase should use fewer roadmap-driven features and more evidence-driven selection:

1. implement CP81 standard-library member semantics against the retained project blockers;
2. implement CP82 flow/definite-assignment parity without weakening supported diagnostics;
3. implement CP83 practical tsconfig breadth;
4. reduce and close the CP84 parser/type-grammar blockers;
5. run CP85 against the same retained projects and choose the next smallest slices from measured deltas.

This is how the project avoids checkpoint eternity. Checkpoints remain the unit of work, but real adoption evidence - not the desire to keep adding features - chooses their content.