BACK_TO_CASE_STUDIES
CODE_ANALYSIS / SYNEVID / ACTIVE_DEVELOPMENT / SOURCE 05E1148

SynEvid

Deterministic repository change analysis and policy evidence

A Rust research prototype that parses supported source code into a typed dependency graph, traces bounded change impact, evaluates configured rules, and emits reports for people and automation to inspect.

VIEW_SOURCE
RESEARCH PROTOTYPEACTIVE DEVELOPMENT + TESTINGWORKSPACE V0.1.021 RUST ENGINE CRATESTYPESCRIPT + PYTHONNO MODEL IN COREAPACHE-2.0
SOURCE SNAPSHOT
05e1148
main branch checkout reviewed for this page
WORKSPACE CRATES
21 + tests
21 engine crates plus the integration-test crate
LANGUAGE ADAPTERS
02
TypeScript/JavaScript and Python
LOCAL STORAGE
SQLite
snapshots, findings, and content-addressed artifacts
EVIDENCE_CAVEAT / BENCHMARK NOT RECONCILED

The repository publishes two different benchmark summaries.

The README describes a 50-task benchmark, while the committed JSON report records 10 tasks for each baseline. The reported metrics also differ: README versus reproduction report gives baseline recall of 68.27% versus 71.67%, and engine precision/F1 of 5.98%/10.80% versus 6.11%/10.87%. Both artifacts show 100% engine recall alongside very low precision; the report also records a failed token-cost gate. These are repository-reported artifacts, not reproduced for this portfolio review.

README CLAIM
Tasks described50Baseline recall68.27%Engine precision / F15.98% / 10.80%Engine tokens / task2,693
COMMITTED REPRODUCTION REPORT
JSON task_count10 per baselineBaseline recall71.67%Engine precision / F16.11% / 10.87%Engine tokens / task2,338.5

The README advertises 831 passing tests. No test command or current CI run was executed or independently checked for this write-up.

01 / PROBLEM AND SCOPE

Make code change consequences inspectable

A coding agent or developer changes one symbol and needs to know which callers, contracts, rules, and tests may be affected. SynEvid explores a local, repeatable analysis path that turns supported source relationships into a bounded graph query and explicit evidence.
01 / INPUT

A repository snapshot and, optionally, a previous snapshot or Git revision.

02 / ANALYSIS

Static parsing and rule evaluation over supported syntax; there is no LLM in the correctness crates.

03 / OUTPUT

Reachable entities, paths, findings, coverage state, and JSON, terminal, or SARIF reports.

This is a code-analysis system rather than a generative model: the inspected Rust core contains parser and graph algorithms, with no LLM inference path or training loop in that core.

02 / SYSTEM ARCHITECTURE

A deterministic analysis core with separate adapters and interfaces

The workspace has 21 Rust engine crates and a separate integration-test crate. The architecture below follows checked source modules and the configured CLI, MCP, inspector, and CI surfaces; it is not a claim that every path has been deployed or independently validated.
SYSTEM BLUEPRINT / REVIEWED SOURCE BOUNDARIES
MAIN SNAPSHOT 05E1148
SynEvid source architectureA local repository is scanned and parsed by TypeScript and Python adapters into a typed symbol graph. Deterministic analysis engines produce reports and BLAKE3 digests. The CLI, stdio MCP process, static web inspector, and GitHub Actions workflow are separate integration surfaces. SQLite is local analysis storage.STATIC ANALYSIS PATH / SOURCE CODE IS PARSED, NOT EXECUTEDREPOSITORY INPUTworking tree + optional Gitread-only source inspectionSCAN + PARSEignore rules + file limitsTypeScript / Python adaptersTYPED GRAPHsymbols + contracts + edgescoverage and provenanceANALYSIS ENGINESdiff + bounded impactinvariants + contract checksREPORT + RECEIPTtext / JSON / SARIFcanonical BLAKE3 digestLOCAL SQLITE + CONTENT-ADDRESSED CACHEsnapshots / run findings / file artifacts / analysis cacheINTEGRATION SURFACES / LOCAL TOOLING AND EXTERNAL CI ARE DISTINCTLOCAL CLIautopsy commandsMCP SERVERstdio; invokes local CLIWEB INSPECTORopens exported JSONCI WORKFLOWruns CLI on a CI runner
The correctness core is Rust-based and has no model call in its analysis path. The MCP server invokes a local CLI binary; the static inspector reads exported artifacts. GitHub Actions runs outside the local machine.

CORE ANALYSIS GROUPS

Repository scan and language adapters feed symbol, graph, diff, and contract models. Impact traversal and invariant evaluation consume those models. Temporal history, test selection, telemetry, co-change analysis, and service catalog features live in additional crates.

INTEGRATION BOUNDARY

The MCP server uses stdio and invokes a local autopsy process. The standalone web inspector consumes exported artifacts. GitHub Actions runs the CLI in CI; its presence in the repository is workflow configuration, not evidence of a successful latest run.

03 / CHANGE-IMPACT MODEL

Bounded reachability over typed, provenance-aware edges

The analyzer represents supported symbols as graph nodes and extracted relations as directed edges. The impact command selects a direction, allowed edge kinds, depth limit, and node budget. Paths are returned in deterministic order; if the search is cut off, the result marks itself truncated.
BOUNDED IMPACT / ILLUSTRATIVE STATIC GRAPH
Illustrative bounded impact graphA changed authorization symbol links through statically extracted call and import edges to a route and a test suite. A separate unknown dynamic edge is shown as unresolved and does not become a verified graph edge.CALLSCOVERAGE / IMPORTDYNAMIC EDGE: UNKNOWN, NOT ASSERTEDCHANGE SEEDsrc/auth.ts::checkTokensnapshot / diff frontierDEPENDENT SYMBOLroutes/session.tsshortest path + provenanceAFFECTED TEST CANDIDATEtests/session.test.tsselection may widen on unknowns
Example only, not a captured run. Edges are extracted from supported syntax and carry adapter coverage; dynamic dispatch is not inferred as a verified dependency.
BOUNDED IMPACT SET
I(d, K, D, s) = { v ∈ V | dist over allowed edges K in direction D from s to v ≤ d }

s is the seed symbol, d the maximum path depth, K the selected edge kinds, and D the requested traversal direction. The code uses breadth-first traversal, caps newly added impact nodes at a configured node budget B, and marks results truncated when depth or budget prevents further traversal. It ranks paths by length, then stable lexical identifiers. This is a static dependency estimate, not proof of runtime execution.

04 / END-TO-END REVIEW PATH

From a baseline to a policy result

This sequence follows the CLI commands documented in the repository. The baseline and worktree are inspected locally; an invariant check returns pass, fail, or unknown according to the analysis coverage and configured rules.
01 / BASELINE

Scan and store a repository snapshot.

02 / CHANGE

Compare snapshots into file, symbol, edge, and contract deltas.

03 / IMPACT

Traverse bounded dependencies from changed symbols.

04 / VERIFY

Evaluate configured forbidden-dependency, layer, cycle, or API rules.

05 / REVIEW

Inspect findings, paths, coverage, and report digest.

autopsy baseline --format json
autopsy diff --before <snapshot_id> --format json
autopsy impact -s "src/auth.ts::checkToken" --direction backward --max-depth 5
autopsy verify --strict --invariants-file .autopsy/invariants.yml
autopsy explain <finding_id>
05 / DETERMINISM AND EVIDENCE

Stable output is part of the design

Core data structures and receipt builders sort collections before serialization. The evidence receipt hashes canonical JSON fields with BLAKE3, so reviewers can check whether those fields still match the recorded digest.
RECEIPT DIGEST
digest = BLAKE3(JSON(canonical(fields)))

The receipt includes finding and rule identifiers, snapshots, analyzer version, locations, paths, and deltas. This is a content-integrity digest, not a digital signature or proof that the analyzer's conclusion is correct.

UNKNOWN COVERAGE
incomplete analysis -> UNKNOWN / PARTIAL

The invariant evaluator does not convert unknown or partial coverage into a pass. Test selection widens its plan when changed semantics or suite mappings cannot be resolved. The practical value depends on adapter coverage and the configured policies.

06 / VALIDATION RECORD

Published evidence, execution evidence, and limitations

The repository contains CI definitions and benchmark artifacts. This review inspected the source tree at the pinned commit but did not execute the Rust workspace or verify a current GitHub Actions run.
SOURCE SUPPORT

Two adapters are present for TypeScript/JavaScript and Python. Dynamic or unresolved constructs can result in partial or unknown coverage.

TEST STATUS

The README claims 831 passing tests. This audit did not run the suite, and the number is not independently attributed here to a specific CI run.

BENCHMARK

The repository describes 50 tasks across five TypeScript repositories. Its README and committed reproduction report disagree on baseline recall and engine precision/F1.

REPORTED TRADEOFF

The committed reproduction report reports 100% recall but 6.11% precision and 10.87% F1 for SynEvid, with token cost above the baselines. Treat this as provisional until the artifacts are reconciled and rerun.

SECURITY CLAIMS

The source describes read-only analysis and local execution. No independent security audit or production deployment is claimed by this case study.

RELEASE STATE

Cargo workspace metadata declares 0.1.0 and the changelog labels work unreleased. This page uses a source commit rather than claiming a published release.

RESEARCH AND ENGINEERING WORK THAT WOULD STRENGTHEN THE NEXT REVIEW
  • Reconcile benchmark README, JSON, and Markdown from one reproducible run with per-task raw outputs.
  • Measure precision and review burden alongside recall; define when a broad impact set is useful.
  • Publish a commit-pinned CI result and a reproducible install/run path for each integration surface.
  • Expand parser coverage only with explicit unsupported-syntax reporting and adapter conformance evidence.
07 / SOURCE INDEX

Review the implementation at the audited commit

The links below are pinned to the main snapshot inspected for this case study. They point to implementation files and committed validation artifacts so a reviewer can compare each description with its source.

Audited public source snapshot: 05e11481575f59acda2f107badbad87ecb745dbd. Counts and lifecycle statements on this page describe that checkout; later commits may change them.

END_OF_CASE_STUDY

SynEvid is a deterministic code-analysis prototype with a broad set of source-backed components. Its benchmark artifacts need reconciliation, and this review does not establish current test status or production readiness.