# MDReader implementation-entry contract

Status: research-only future-work contract; application implementation
deferred beyond the current program

Evidence class: planning and conformance contract, not runtime evidence

Evidence cut: repository commit
`ea46fa3a64627c3db9e4db09b8e4e26531676f92` (`accept Slice 5 loss and
schema diff`, 23 July 2026)

## Plan

### Objective

Prepare a research-only, dependency-ordered future-work entry into MDReader
development
without presenting the accepted Paper 18 design as an implemented
application. The first implementation wave is headless and fixture driven. It
may freeze a Markdown profile, create an immutable corpus, define typed
application-domain contracts, and prove that a fixture adapter obeys a
mock-safe boundary. It does not create a browser interface, local database,
server, synchronization path, or result-bearing application claim.

This artifact does not authorize that implementation wave. A later explicit
implementation task must select and execute backlog items.

### Governing evidence

This contract reads the following evidence in descending order of authority:

1. `coordination/verification-status.md` and
   `coordination/releases/slice-5.md` for the live accepted implementation
   boundary;
2. `research/implementation-roadmap.md` for Slice 6 through Slice 14
   dependency order and native exit gates;
3. `papers/18-mdreader/paper.tex`,
   `papers/18-mdreader/reproducibility.md`,
   `papers/18-mdreader/research/evidence-dossier.md`, its author ledgers, and
   `reviews/mdreader-agy-review.md` for the accepted P18 contract and its exact
   nonclaims;
4. `research/paper-manifest.md` for the P18 research question, dependencies,
   deliverables, and verification target;
5. `research/repository-website-scaffold-plan.md` for the separation between
   `apps/mdreader/` and the publication website; and
6. `context/01-markdown-viewer-and-search.md` only as immutable product-source
   evidence, never as code or result evidence.

The accepted P18 artifact is a 28-page, AGY-accepted design and falsification
contract. It does not establish a parser, fixture corpus, projection engine,
overlay engine, API, database, user interface, accessibility result, security
result, user study, or performance result.

### Live dependency audit

The accepted Slice 5 commit contains:

- `catdb-core`;
- `catdb-ir`;
- `catdb-schema`;
- `catdb-mapping`;
- `catdb-migration`; and
- `catdb-cli`.

Its only root third-party workspace dependencies are `serde`, `serde_json`,
and `tempfile`. An interrupted uncommitted `catdb-bench` scaffold was removed
when the program adopted the research-only completion boundary. No benchmark
harness or result is part of the accepted repository state.

`apps/mdreader/` and `apps/website/` still contain no files. There is no
MDReader package manifest or lockfile and no current CatDB crate for query
semantics, provenance, storage, SQLite, PostgreSQL, catalog, connectors,
workspaces, distribution, or the server.

Slice 5 is internally accepted computational evidence for its declared finite
loss-and-diff boundary. Slices 6--14 are deferred future engineering. No live
query, provenance, backend, workspace, API, or application result follows from
Slice 5.

### Dependency graph

```text
available now, without runtime claims

E0 evidence guard
  -> E1 Markdown profile
  -> E2 immutable corpus and golden manifests
  -> E3 source/projection domain contracts
  -> E4 overlay/authority domain contracts
  -> E5 versioned gateway and fixture adapter
  -> E6 headless conformance report

runtime path, fail closed

Slice 6 query/provenance semantics
  -> Slice 7 SQLite vertical path
  -> Slices 8-11 backend, catalog, federation, materialization
  -> Slice 12 workspace semantics
  -> Slice 14 local server/API/MDReader

optional synchronization path

Slice 12 -> Slice 13 distribution -> Slice 14 sync capability
```

Completing E0 through E6 permits only a statement such as “the MDReader
parser/domain contract passes its immutable fixture suite.” It does not permit
“MDReader is implemented” or “MDReader executes CatDB.”

### Scope

In scope now:

- a versioned Markdown parser profile;
- immutable source and expected-result fixtures;
- typed source, projection, overlay, evidence, inspector, and diagnostic
  contracts;
- a transport-neutral gateway boundary;
- a fixture-only gateway that cannot emit runtime-computed evidence;
- headless unit, property, schema, and conformance tests; and
- a reproducible conformance report tied to exact hashes.

Out of scope for this entry artifact:

- UI components, routes, screenshots, browser tests, or desktop packaging;
- a Node or Rust package scaffold;
- SQLite schema or driver work;
- CatDB query, provenance, planner, connector, catalog, workspace,
  distribution, or server code;
- PostgreSQL or network synchronization;
- retrieval indexes, embeddings, reranking, or benchmarks;
- accessibility, security, usability, or performance claims;
- publication website changes;
- paper, README, `CITATION.cff`, release, commit, deployment, or Slack work.

### Review policy for later code

Paper review remains the full AGY paper-review process already completed for
P18. Code artifacts in this backlog do not require a deep Claude or Codex
review by default. Their primary gates are native build, unit, integration,
end-to-end where applicable, and accessibility checks. At most one quick AGY
code review may be requested after those gates pass.

A deep security review is added only when a slice introduces authentication,
network access, external writes, workspace authorization, destructive
operations, or execution/rendering of untrusted content. The review scope must
name the triggering surface rather than re-review unrelated parser/domain
code.

## Act

### Evidence-state contract

Every externally visible record carries an evidence value. Transport success
is not evidence of semantic computation.

```ts
type FixtureEvidence = {
  kind: "fixture";
  contractVersion: string;
  manifestId: string;
  manifestSha256: string;
  caseId: string;
};

type StructuralEvidence = {
  kind: "structural_only";
  contractVersion: string;
  artifactId: string;
  artifactSha256: string;
  limitations: string[];
};

type RuntimeEvidence = {
  kind: "runtime_computed";
  contractVersion: string;
  runtimeCommit: string;
  sourceArtifactIds: string[];
  gateArtifactIds: string[];
};

type UnavailableEvidence = {
  kind: "blocked" | "unsupported";
  contractVersion: string;
  blockerIds: string[];
  explanation: string;
};

type Evidence =
  | FixtureEvidence
  | StructuralEvidence
  | RuntimeEvidence
  | UnavailableEvidence;
```

The fixture adapter may construct only `FixtureEvidence`,
`StructuralEvidence`, or `UnavailableEvidence`. Its type signature must make
`RuntimeEvidence` unrepresentable. A UI or consumer must derive words such as
“computed,” “validated,” and “supported” from this tagged value, not from HTTP
status, the presence of data, a green color, or a successful mock request.

`RuntimeEvidence` remains reserved until the supplying slice has passed its
native commands and its exact review/release artifact IDs are present.

### Markdown parser profile

The first proposed profile ID is `mdreader.markdown.v1`. It is not frozen
merely by appearing in this plan. It becomes frozen only when the profile
document, schema, manifest, and independent golden corpus all pass review.
After any run references the profile, corrections create `v2`; they do not
mutate `v1`.

#### Required admitted syntax

- CommonMark 0.31.2 block and inline structure;
- GFM tables, task-list items, strikethrough, and autolinks;
- headings, paragraphs, lists, block quotes, thematic breaks, fenced and
  indented code blocks, raw HTML, links, and images;
- exact code-fence information strings, including `mermaid`, as source data;
- ordering and parent/child relationships; and
- exact half-open byte spans into the observed source revision.

#### Repository-dialect policy

YAML front matter, footnotes, wiki links, inline/display mathematics, and
specialized Mermaid rendering are not silently promoted into semantic nodes.
For `v1` each feature must be assigned exactly one reviewed disposition:

- admitted with a named extension and fixtures;
- preserved as ordinary Markdown text or code with no extra semantics; or
- rejected/recovered with a stable diagnostic.

An implementation may not infer a disposition from the parser library's
default plugins. The parser package, plugin list, package versions, enabled
options, and normalization rules are pinned in the future lockfile and
recorded with each projection.

#### Source and span rules

- Input is exact bytes, not a pre-normalized string.
- `contentSha256` is computed over those exact bytes.
- Byte offsets are authoritative; line and column values are derived.
- The newline policy distinguishes LF, CRLF, and mixed-newline input.
- Invalid UTF-8 has an explicit reject or byte-preserving recovery outcome.
- A read-only parse or projection must leave the source hash unchanged.
- Recovered syntax remains marked recovered and retains diagnostics.
- File moves do not automatically change logical source identity.
- Byte-equal copies do not automatically share logical source identity.

### Immutable corpus and fixture contract

The future implementation wave uses new, MDReader-specific paths and does not
mutate `fixtures/schema-v1.schema.json` or the accepted Slice 5 corpus:

```text
research/mdreader-markdown-profile-v1.md
fixtures/mdreader/schema-v1.schema.json
fixtures/mdreader/manifest-v1.json
fixtures/mdreader/cases/<case-id>/
  source/<relative-path>
  observation.json
  projection.expected.json
  overlays.input.json
  overlays.expected.json
  gateway.expected.json
fixtures/mdreader/regressions/<case-id>/
```

Once `manifest-v1.json` is referenced by a conformance run, every listed byte
file and expected artifact is immutable. A changed artifact receives a new
case ID or manifest version. Generated counterexamples are added as new
regression fixtures; passing output never overwrites a golden file.

#### Manifest fields

```ts
type MdReaderFixtureManifest = {
  schemaVersion: "mdreader.fixture.v1";
  contractVersion: string;
  parserProfile: {
    id: string;
    specificationRefs: string[];
    implementationPackage?: string;
    implementationVersion?: string;
  };
  cases: Array<{
    id: string;
    category:
      | "source"
      | "projection"
      | "overlay"
      | "authority"
      | "inspector"
      | "gateway"
      | "unsupported";
    sourceFiles: Array<{
      path: string;
      sha256: string;
      byteLength: number;
    }>;
    artifacts: Array<{
      path: string;
      sha256: string;
      role: string;
    }>;
    invariantIds: string[];
    expectedOutcome: "ok" | "diagnostic" | "unsupported" | "error";
    evidenceKind: "fixture" | "structural_only";
  }>;
};
```

The manifest validator must reject missing files, unlisted files, duplicate
case IDs, duplicate logical IDs, path traversal, absolute paths, symlink
escapes, checksum mismatches, unknown invariant IDs, mutable timestamps in
golden output, and a fixture claiming `runtime_computed` evidence.

#### Minimum first corpus

| Case family | Minimum seeded behavior |
|---|---|
| `MDR-SRC` | empty file, LF, CRLF, mixed newlines, Unicode, invalid UTF-8 policy, rename, byte-equal copy |
| `MDR-CM` | headings, paragraphs, nested lists, block quote, inline/fenced code, links, images, raw HTML |
| `MDR-GFM` | table, task list, strikethrough, autolink |
| `MDR-DIALECT` | front matter, footnote, wiki link, math, and Mermaid each exercise their reviewed disposition |
| `MDR-RECOVERY` | unterminated fence, malformed link, broken table, and unsupported construct retain diagnostics |
| `MDR-SPAN` | every projected object resolves to exact bytes; multibyte characters and mixed newlines are included |
| `MDR-OVERLAY` | author assertion, deterministic extraction, model suggestion, review, approval, rejection, supersession |
| `MDR-ANCHOR` | exact anchor, moved block, changed block, ambiguous copy, stale anchor, explicit reattachment |
| `MDR-GATEWAY` | fixture success, structural-only result, blocked runtime operation, stable diagnostic |
| `MDR-NONCLAIM` | no fixture can label a mock, recovered parse, or structural record as computed or executed |

Golden results are authored or checked independently of the parser code.
Parser output may never generate its own oracle in the same test.

### Typed domain contract

These types are normative shapes for the future schema and generated
TypeScript bindings. They are not a claim that bindings currently exist.

```ts
type Id<T extends string> = string & { readonly __type: T };

type SourceRevision = {
  id: Id<"SourceRevision">;
  sourceId: Id<"Source">;
  workspaceId: Id<"Workspace">;
  relativePath: string;
  contentSha256: string;
  byteLength: number;
  parserProfileId: string;
  parserImplementation: string;
  parserVersion: string;
  observedAt: string;
  diagnostics: ParserDiagnostic[];
};

type SourceSpan = {
  revisionId: Id<"SourceRevision">;
  startByte: number;
  endByte: number;
  startLine: number;
  startColumn: number;
  endLine: number;
  endColumn: number;
};

type ProjectedNode = {
  id: Id<"ProjectedNode">;
  revisionId: Id<"SourceRevision">;
  kind:
    | "document"
    | "section"
    | "block"
    | "link"
    | "task";
  parentId?: Id<"ProjectedNode">;
  ordinal: number;
  span: SourceSpan;
  attributes: Record<string, string | number | boolean | null>;
  recovered: boolean;
  evidence: FixtureEvidence | UnavailableEvidence;
};

type ParserDiagnostic = {
  code: string;
  severity: "info" | "warning" | "error";
  span?: SourceSpan;
  message: string;
  recovery?: string;
};

type OverlayKind =
  | "claim"
  | "evidence"
  | "decision"
  | "requirement"
  | "task"
  | "component"
  | "agent_context";

type OverlayStatus =
  | "suggested"
  | "reviewed"
  | "approved"
  | "rejected"
  | "superseded"
  | "invalidated";

type OverlayAuthority =
  | "author"
  | "reviewer"
  | "deterministic_extractor"
  | "model_suggestion";

type OverlayAssertion = {
  id: Id<"OverlayAssertion">;
  kind: OverlayKind;
  schemaVersion: string;
  anchors: SourceSpan[];
  relations: Array<{
    predicate: string;
    targetId: string;
  }>;
  status: OverlayStatus;
  authority: OverlayAuthority;
  generatedBy: string;
  createdFromRevision: Id<"SourceRevision">;
  createdAt: string;
  supersedes?: Id<"OverlayAssertion">;
  evidence: FixtureEvidence | StructuralEvidence | UnavailableEvidence;
};
```

Validation rules:

- `startByte <= endByte <= byteLength`;
- a span's `revisionId` must match the containing revision;
- ordinals are unique and contiguous within a parent;
- all overlay anchors resolve or carry an explicit stale/ambiguous violation;
- `model_suggestion` and `deterministic_extractor` cannot directly create
  `approved`;
- approval records the reviewer/author transition as a new immutable event;
- rejected, superseded, and invalidated assertions remain inspectable;
- unknown attributes survive round trips but do not acquire semantics; and
- every serialization is canonical and versioned before hashing.

Mapping, migration, violation, provenance, diff, and query inspector records
may be defined now as normalized transport shapes. Until their supplying
runtime exists, their evidence type is restricted to fixture,
structural-only, blocked, or unsupported. A schema definition alone never
authorizes a computed status.

### Versioned API and mock-safe boundary

The initial proposed transport contract is `mdreader.api.v1alpha1`. The UI,
when separately authorized later, depends only on `MdReaderGateway`. It must
not import fixture JSON directly, call CatDB crates, infer state from route
names, or encode mock-only fields.

```ts
type CapabilityState =
  | "contract_only"
  | "fixture_conformant"
  | "structural_only"
  | "runtime_computed"
  | "blocked"
  | "unsupported";

type ApiResult<T, E extends Evidence = Evidence> = {
  apiVersion: "mdreader.api.v1alpha1";
  requestId: string;
  capability: string;
  outcome: "ok" | "blocked" | "unsupported" | "error";
  evidence: E;
  data?: T;
  diagnostics: Array<{
    code: string;
    message: string;
    details?: Record<string, unknown>;
  }>;
};

interface MdReaderGateway<E extends Evidence = Evidence> {
  capabilities(): Promise<ApiResult<CapabilityRecord[], E>>;
  sourceRevision(id: string): Promise<ApiResult<SourceRevision, E>>;
  projection(revisionId: string): Promise<ApiResult<ProjectedNode[], E>>;
  overlays(revisionId: string): Promise<ApiResult<OverlayAssertion[], E>>;
  inspector(kind: string, id: string): Promise<ApiResult<unknown, E>>;
  compare(leftRevision: string, rightRevision: string):
    Promise<ApiResult<unknown, E>>;
  query(request: unknown): Promise<ApiResult<unknown, E>>;
}

type FixtureGateway =
  MdReaderGateway<FixtureEvidence | StructuralEvidence | UnavailableEvidence>;
```

Required boundary behavior:

- `FixtureGateway` reads only files bound by the immutable manifest.
- A missing fixture is an error, never synthesized fallback data.
- `query`, live migration, computed provenance, historical workspace queries,
  and synchronization return `blocked` with exact slice blocker IDs.
- The fixture adapter and future HTTP adapter run the same consumer contract
  tests.
- Runtime operations cannot be enabled by a feature flag alone; their
  capability records require gate artifacts.
- Unknown enum values fail closed at the adapter boundary and remain visible
  in diagnostics.
- Cancellation, authorization, and atomicity fields may be present in the
  schema now but cannot report a pass before Slice 14 native tests.

Planned API operations and current maximum evidence:

| Operation | Current maximum | Runtime promotion gate |
|---|---|---|
| source bytes and revision fixture | fixture | parser/source conformance |
| projected document structure | fixture after parser suite | parser/profile conformance |
| overlay assertions and transitions | fixture or structural-only | overlay property/conformance suite |
| mapping/path inspector record | structural-only | accepted library/API equivalence |
| bounded Delta presentation | structural-only | Slice 14 API equivalence over accepted runtime result |
| semantic diff | fixture or structural-only | live workspace/runtime gate |
| provenance inspector | fixture only | Slice 7 plus Slice 14 API equivalence |
| local query | blocked | Slice 7, then Slice 12 and Slice 14 |
| historical workspace query | blocked | Slice 12 and Slice 14 |
| PostgreSQL synchronization | blocked | Slice 13 and explicit Slice 14 capability |

### Dependency-ordered TDD backlog

Every item follows red test, smallest implementation, native verification,
and artifact capture. At most one quick AGY code review follows the completed
native gates by default. A test file that never failed for the intended reason
does not satisfy the red step.

#### Work available now

| ID | Depends on | Red test first | Smallest implementation | Exit evidence |
|---|---|---|---|---|
| `MDR-E0` evidence sentry | none | reject `runtime_computed` in fixture manifests and fixture gateway types | evidence union and manifest/schema rule | negative schema/type tests pass |
| `MDR-E1` parser profile | `MDR-E0` | profile coverage test fails for every syntax feature without a disposition | reviewed `mdreader.markdown.v1` profile document | profile coverage report has no unclassified feature |
| `MDR-E2` fixture schema | `MDR-E1` | checksum, traversal, duplicate-ID, unlisted-file, and forbidden-evidence cases fail | MDReader fixture JSON Schema and validator | validator negative suite and clean manifest pass |
| `MDR-E3` immutable corpus | `MDR-E2` | each minimum corpus family initially lacks its golden result | hand-authored source bytes and independent expected manifests | all artifacts hash-close; no implementation-generated oracle |
| `MDR-E4` parser/projection | `MDR-E3` | exact kind, order, hierarchy, diagnostics, and byte spans fail | smallest pinned parser adapter for the frozen profile | golden suite, source-preservation properties, and regression suite pass |
| `MDR-E5` domain bindings | `MDR-E2` | invalid spans, noncanonical serialization, unknown versions, and broken refs fail | versioned schemas plus generated bindings | schema round trips and canonical hashes pass |
| `MDR-E6` overlay reducer | `MDR-E5` | authority laundering, stale anchors, ambiguous copies, and silent reattachment fail | pure immutable transition/validation functions | transition properties and seeded anchor cases pass |
| `MDR-E7` inspector records | `MDR-E5`, `MDR-E6` | missing assignment, status, source anchor, evidence, or text equivalent fails | normalized record builders over fixtures only | complete-field conformance suite passes |
| `MDR-E8` fixture gateway | `MDR-E3`, `MDR-E5`, `MDR-E7` | consumer contract fails on missing, blocked, unknown, and stale cases | `FixtureGateway` with no UI | shared gateway contract suite passes; no runtime evidence constructible |
| `MDR-E9` headless conformance | `MDR-E0`-`MDR-E8` | release manifest fails when any artifact, hash, nonclaim, or gate is missing | deterministic conformance runner and report | exact source/lock/fixture hashes, logs, and review bind one result |

No UI work enters this wave. After `MDR-E9`, a separately approved UI task
may consume `MdReaderGateway`; it still may not claim live CatDB execution.

#### Work blocked on runtime slices

| ID | Blocking slice | Why blocked | Required unblock evidence |
|---|---|---|---|
| `MDR-R6` query/provenance transport shapes promoted beyond fixtures | Slice 6 | the minimal query and provenance profiles and independent finite reference are not frozen | Slice 6 profile, immutable v2 fixtures, independent Haskell results, small-model checks, and review pass |
| `MDR-R7` local SQLite execution and computed provenance | Slice 7 | no query, planner, storage, connector, SQLite, or provenance crates exist | `SYS-QRY-01` and `SYS-PROV-01` SQLite-side equivalence plus native hot-path tests |
| `MDR-R8-11` PostgreSQL, catalog/connectors, federation, and materialization | Slices 8-11 | Slice 12 is transitively unreachable without them | each slice's differential, conformance, failure, provenance, and recovery gates |
| `MDR-R12` workspaces, historical queries, live semantic diff, isolation, atomic merge, and authorization model | Slice 12 | local Slice 14 explicitly enters only after workspace semantics pass | `SYS-WS-01` through `SYS-WS-03`, failpoint atomicity, historical reproduction, and isolation |
| `MDR-R14L` server API, HTTP gateway, CLI/server/application equivalence, and result-bearing local UI | Slice 14 after Slice 12 | `catdb-server` and public API do not exist | API contract, semantic equivalence, cancellation/atomicity, workspace authorization, native build/unit/integration tests, app E2E and accessibility gates, plus at most one quick AGY code review |
| `MDR-R13` distributed operation and optional sync | Slice 13 | duplication, reordering, partitions, conflicts, and recovery have no accepted operation semantics | `SYS-DIST-01`, replay, partition-heal, coordination-required, recovery, and stale-state tests |
| `MDR-R14S` PostgreSQL synchronization UI/capability | Slice 14 after Slice 13 | sync is optional and may not gate local operation | negotiated capability, explicit conflict/auth rules, fault tests, local continuity, API/application checks |

Slice 7 is a necessary but insufficient dependency for a result-bearing local
application. Slice 12 is the direct local-mode entry gate. Slice 13 is required
only for synchronization. The serial roadmap also requires Slices 8 through
11 between Slice 7 and Slice 12.

`MDR-R14L` triggers deep security review because it contains workspace
authorization and a network API. `MDR-R14S` triggers it because it contains
authentication, network transport, remote writes, conflict handling, and
untrusted peer input. A headless local parser/domain wave does not trigger deep
security review unless its implementation executes untrusted content or writes
outside the fixture sandbox.

### Conformance levels and permitted statements

| Level | Required evidence | Permitted statement |
|---|---|---|
| `C0 contract` | this reviewed plan only | “MDReader has an implementation-entry contract.” |
| `C1 fixtures` | E0-E3 | “A versioned MDReader corpus contract and immutable fixtures exist.” |
| `C2 headless` | E0-E9 | “The named parser/domain contract passes its fixture suite.” |
| `C3 SQLite dependency` | Slice 7 | “The named CatDB SQLite query/provenance profile passes its runtime gates.” MDReader still not implied. |
| `C4 local application` | Slice 12 plus Slice 14 local gates | “The named MDReader local capability passes the published application matrix.” |
| `C5 synchronized capability` | Slice 13 plus Slice 14 sync gates | “The named optional synchronization capability passes its declared fault matrix.” |

P18 manuscript acceptance is not a conformance level. It supplies the design
contract used to define these levels.

## Verify

### Entry acceptance

This contract may be reopened by a future implementation program only when:

- the live repository still has no conflicting MDReader implementation;
- the P18 manuscript remains classified as accepted design, not application
  evidence;
- Slice 5 is the highest accepted runtime slice and Slice 6 remains the first
  deferred semantic gate, unless a newer accepted release record says
  otherwise;
- the planned fixture paths do not mutate accepted fixture schemas or cases;
- every now-available backlog item has a named red test and exit artifact;
- every live runtime feature has a slice blocker and promotion gate;
- later code gates follow build/unit/integration/E2E/accessibility first, with
  at most one quick AGY code review by default and deep security review only
  for a named triggering surface;
- the MDReader app remains separate from the publication website; and
- no release or product statement can be inferred from mock success.

### Verification commands for this planning artifact

```bash
git diff --check -- \
  research/mdreader-implementation-entry-contract.md \
  coordination/mdreader-implementation-entry-status.md
test ! -f apps/mdreader/package.json
test -z "$(find apps/mdreader -mindepth 1 -print)"
test -z "$(find apps/website -mindepth 1 -print)"
cargo metadata --no-deps --format-version 1
rg -n "accepted.*design|not runtime evidence|does not establish|blocked" \
  research/mdreader-implementation-entry-contract.md \
  coordination/mdreader-implementation-entry-status.md
git status --short -- \
  research/mdreader-implementation-entry-contract.md \
  coordination/mdreader-implementation-entry-status.md
```

The Cargo metadata command is read-only current-working-tree evidence. It may
include concurrent unaccepted work and does not make an MDReader claim.

### Nonclaims

This artifact does not establish:

- an implemented MDReader application or package;
- a selected JavaScript framework, parser package, database driver, or server;
- a parser passing CommonMark, GFM, or repository-dialect fixtures;
- typed overlays operating over live files;
- a correct mapping, migration, diff, provenance, query, workspace, or sync
  result;
- a mock as a demo of live runtime behavior;
- accessibility, security, usability, responsiveness, durability, or
  performance;
- executable benchmark groups; or
- a release, commit, deployment, public website, or notification.