archy MCP server

<!-- mcp-name: io.github.hslee16/archy -->

Your folders show your architecture. Your imports decide it.

archy turns a Python import graph into something an agent can use: blast radius before an edit, the tests that edit affects, the modules most at risk. And it fails when the graph disagrees with the layers you declared. Same graph either way, as a CLI and an MCP server, every session and in CI.

[!IMPORTANT]

Status, 2026-09-10: active, and pointed at the loop rather than the surface area.

What archy does. One graph, two front ends. It parses a Python project's

imports and calls once, keeps the parse cached, and answers the questions a

file tree cannot: what does this change reach, which tests does that affect,

where are the cycles, and does the graph still agree with the layers you

declared. It runs as a CLI in CI and as an MCP server inside an agent session,

off the same graph either way, and it fails when the declared architecture

and the real one disagree.

Where it is going: deeper into that loop, not wider. The local-model

question that reopened this project on 2026-09-02 is **closed, as six

interventions, none positive**, two of them measured as costing MORE than

their control. The write-up is Study 8 in

docs/WHATDIDNTWORK.md, and it is the fifth

pre-registered null published here. The feature that line produced,

conventions --emit-headers, is kept, because it is derived rather than

hand-authored, cheap, and --check stops it rotting. Only the claim attached

to it is retired.

**What those six nulls did establish is where the failure lives: delivery and

retrieval, not capability.** Across 132 agent transcripts on a pinned tree,

read fired in 132 of 132 runs with a median of 9.5 calls before the first

edit; archy fired in 84 of 132, with a median of zero calls before it.

Every archy surface is pull. The model reaches for it after it has already

decided, or not at all. Two payloads pushed through the one channel archy

owns, the file itself, both came out more expensive than their control, which

is evidence about the channel and not the content.

So the working design rule is: **put the answer in the default output of a

command that is already being run**, rather than adding a surface that has to

be discovered first. The live threads follow from it. One is the vacuity

family: a check that could not have failed must not report like one that was

evaluated and held, which is now explicit on the contracts result and is being

finished across the remaining surfaces. The other is two structural refactors

of archy's own code: the module its own tools rate as central and fragile,

and the two files that have grown large enough to hide things. New tools and

new output formats stay gated behind a usage signal.

The discipline does not relax because the project is active. Thresholds

are pre-registered before a run, and any result, including another null, gets

published in docs/WHATDIDNTWORK.md like the

five before it. Nothing archy ships today claims a local-model benefit;

archy brief (v0.46) shipped explicitly on judgment ahead of that

measurement rather than

Shortened. The full README is on GitHub.