scip-query 0.18.0 → 0.19.1

package/docs/architecture-coherence-vision.md

@@ -0,0 +1,219 @@
+# Architecture Coherence Vision
+
+## Purpose
+
+scip-query should help a maintainer answer two different questions:
+
+1. What architecture does this codebase actually have?
+2. Where does the implementation contradict the architecture the project intends to preserve?
+
+The dependency graph can answer neither question alone. It records which files rely on which other files. Architectural judgment connects those facts to the real responsibilities, public contracts, runtime boundaries, and maintenance work that gave the code its structure.
+
+The product vision is therefore a combination of:
+
+- an `architecture` query that measures declared boundaries and dependency rules;
+- a directory-architecture skill that helps an agent discover, name, test, and gradually enforce those rules;
+- drift and health integrations that expose architectural changes without pretending every unusual import is a defect.
+
+## Vocabulary
+
+An architectural boundary is a named group of code with one stable reason to change, such as a domain model, rendering subsystem, persistence adapter, compiler frontend, or deployable service. A folder often represents a boundary, but a folder is only evidence of one: the decisive fact is the responsibility its files jointly serve.
+
+A dependency edge is a directed relationship from code that relies on something to the code it relies on. For an import, `A -> B` means file A imports file B. The direction matters because changes to B can force changes in A.
+
+A boundary edge is the same relationship after file edges are grouped by their architectural boundaries. Ten imports from UI files into domain files form one `ui -> domain` boundary edge with ten pieces of file-level evidence.
+
+An allowed edge is a boundary dependency that agrees with a declared rule. A forbidden edge is an actual dependency that contradicts a declared rule about which responsibilities may rely on which others. Files being far apart or living under different directories does not by itself make the edge forbidden.
+
+A reciprocal dependency is a pair of boundary edges in both directions, such as `source -> parser` and `parser -> source`. It is a review signal because neither boundary can change independently, but it can be intentional when the named boundaries are really one subsystem or meet through a deliberately shared contract.
+
+A strongly connected component is a group of boundaries where every member can reach every other member through dependency edges. Its essential consequence is mutual change pressure: no member is directionally independent of the group. A component with many boundaries is evidence that the current names may not describe real separation.
+
+A cycle-break candidate is a boundary edge inside a dependency cycle whose small amount of file-level evidence makes it a plausible place to inspect first. It is not automatically the correct edge to remove; a single import can expose either an accidental shortcut or a legitimate contract that the boundary model failed to name.
+
+An architecture policy is the project-owned configuration that names boundaries and records dependency directions the maintainers are prepared to defend. Its rules are stronger than inferred folder conventions because the project explicitly chose them.
+
+An architecture ratchet is an enforcement rule that permits recorded existing debt while preventing new violations. It lets a large codebase improve incrementally without requiring a speculative rewrite before the policy becomes useful.
+
+Architectural coherence is the degree to which actual dependencies, named responsibilities, and declared dependency rules describe the same system. The tool should report the evidence needed to improve that alignment, not reduce coherence to a single score.
+
+## Why `drift` Is Not Enough
+
+Drift is movement away from a reference state or established pattern. A system can be statically incoherent without having changed recently, and it can change while remaining coherent. Therefore architecture needs a first-class report rather than being hidden inside `drift`.
+
+`scip-query architecture` owns the complete boundary graph and policy
+evaluation. `scip-query drift --architecture` reuses that report to show
+direct declared violations together with mapping coverage and report-only
+signals; it does not maintain a second policy engine.
+
+Before this work, the source-layer table in
+`src/queries/cleanup/drift-policy.ts` embedded repository-specific knowledge in
+a general-purpose command. An unrelated repository using folders such as
+`src/core` and `src/runtime` could therefore inherit scip-query's rules. That
+table has now been removed: drift consumes only explicit project
+configuration, and an unconfigured repository receives no architecture
+violations.
+
+## Configuration Model
+
+The first configuration shape should be small enough to understand without learning a policy language:
+
+```json
+{
+  "architecture": {
+    "boundaries": [
+      { "name": "domain", "paths": ["src/domain/**"] },
+      { "name": "source", "paths": ["src/source/**"] },
+      { "name": "runtime", "paths": ["src/runtime/**"] }
+    ],
+    "allowedDependencies": {
+      "domain": [],
+      "source": ["domain"],
+      "runtime": ["domain", "source"]
+    },
+    "requireCompletePolicy": true,
+    "requireAcyclic": true
+  }
+}
+```
+
+A boundary row names code; it does not yet prohibit anything. An `allowedDependencies` row is closed: when a row exists for `source`, every cross-boundary dependency not listed in that row is forbidden. A missing row means the project has not made a rule for that boundary yet. Same-boundary dependencies remain allowed.
+
+This distinction lets a large repository describe mature boundaries first while leaving emerging or disputed areas in discovery mode.
+
+`requireCompletePolicy` turns that gradual-discovery model into a finished
+contract: every configured boundary must have a closed row, including an empty
+row for a boundary that may depend on nothing. `requireAcyclic` independently
+forbids multi-boundary strongly connected components. A project should enable
+both only after the observed graph has been classified and repaired.
+
+## What the Analyzer Should Report
+
+The report should preserve both policy truth and graph evidence:
+
+- mapped, unmapped, and ambiguously mapped files;
+- boundary edges with importer count, imported-file count, total file-edge count, and representative file edges;
+- forbidden edges, grouped by boundary pair rather than emitted as a flood of individual imports;
+- reciprocal boundary pairs;
+- strongly connected boundary components;
+- the narrowest internal edges to inspect first for each component;
+- policy coverage: which boundaries have closed dependency rows and which remain descriptive only.
+- resolved `export ... from` dependencies as well as ordinary imports, so
+  published barrel and package surfaces are governed;
+
+The output tiers should remain explicit:
+
+- **Direct finding:** an actual edge contradicts a declared rule, or a declared acyclicity rule is violated.
+- **Signal:** reciprocity, a large connected component, low policy coverage, an unmapped file, or a narrow cycle-break candidate.
+
+Inferred signals should not reduce health scores or block diffs until external calibration shows that acting on them reliably improves real codebases.
+
+## Applying This to an Existing Large Codebase
+
+The tool cannot discover the “best architecture” by optimizing graph shape. The best available architecture is the clearest model that preserves the system's real responsibilities and necessary behavior while reducing accidental change pressure. Finding it requires a staged investigation.
+
+### 1. Inventory the system's referents
+
+Read the repository guidance, package manifests, deployable entry points, routes, public exports, databases, message boundaries, tests, and build graph. Use scip-query to map consumers, dependencies, change surfaces, cycles, locality candidates, and historical co-change.
+
+This identifies what the code actually does and which units already behave as maintenance units.
+
+### 2. Name candidate boundaries
+
+Do not assume every top-level directory is a layer. A layer is a responsibility ordered by dependency direction, such as presentation over application over domain. A subsystem is a responsibility that owns an end-to-end capability, such as authentication or a compiler. A package is a publication or build unit. A service is an independently running unit.
+
+The architecture model may contain all four. The useful name is the one that predicts why its code changes and what it may depend on.
+
+### 3. Classify boundary maturity
+
+- A mature boundary is repeatedly expressed by code, documentation, tests, entry points, ownership, or history.
+- An emerging boundary has a coherent responsibility but inconsistent placement or dependencies.
+- An accidental boundary is mainly a convenience bucket, legacy pile, generated directory, or recent edit cluster.
+
+Only mature boundaries should receive closed dependency rules initially.
+
+### 4. Build a descriptive model first
+
+Add boundary path patterns without `allowedDependencies` rows. Run `scip-query architecture --json` to inspect mapping coverage, actual boundary edges, reciprocal pairs, and connected components.
+
+Revise names and path membership when the graph reveals that a supposed boundary has no independent responsibility or that one responsibility is split across several folders.
+
+### 5. Declare the rules supported by evidence
+
+For each mature boundary, state which other boundaries it is allowed to depend on and why. Record uncertain edges as unresolved decisions instead of silently allowing the entire current graph.
+
+Run the report again. A forbidden edge is now a testable disagreement between implementation and policy, not the tool's opinion about directory distance.
+
+### 6. Baseline and ratchet
+
+Record reviewed existing violations with `scip-query health
+--write-baseline`. Architecture identities name a forbidden boundary pair or
+an explicitly forbidden boundary cycle, so moving a representative file does
+not churn the ratchet. The default `scip-query diff-gate` architecture check
+then rejects new identities while preserving visibility into recorded debt.
+This turns architecture from a one-time diagram into a maintained contract.
+
+### 7. Migrate narrow seams
+
+Start with a narrow edge whose few file dependencies cross a mature rule. Determine whether the right repair is to move code, invert a dependency, extract a genuinely shared contract, combine falsely separated boundaries, or revise the policy.
+
+Verify each slice with tests, typechecking, incomplete-migration checks, architecture analysis, and diff-gate before taking the next one.
+
+## Example: Vega 2.0
+
+For a codebase the size of Vega 2.0, the first pass should not invent a universal stack of layers. It should:
+
+1. identify workspace packages, applications, servers, public entry points, data stores, and major feature or compiler/rendering subsystems;
+2. map actual dependency traffic between those units;
+3. read the architecture and ownership claims already present in docs and package surfaces;
+4. classify candidate boundaries as mature, emerging, or accidental;
+5. configure the mature boundaries descriptively;
+6. inspect reciprocal pairs and large connected components with their file-edge breadth;
+7. close dependency rows only where the intended direction is supported;
+8. baseline existing violations and prevent new ones;
+9. migrate one narrow, high-confidence seam at a time.
+
+The initial result may be a mixture of layers and subsystems. That is preferable to forcing a neat diagram that contradicts the software. The model becomes stronger as verified migrations and maintenance history provide new facts.
+
+## Delivery Sequence
+
+### Slice 1: explicit measurement — implemented
+
+- Add architecture configuration types and validation.
+- Extract the reusable strongly-connected-component algorithm already embedded in `deep-chains`.
+- Add a pure architecture graph analyzer and `scip-query architecture`.
+- Extend the directory-architecture skill with the discover, declare, measure, and ratchet workflow.
+- Keep architecture outside health scoring and diff-gate blocking.
+
+### Slice 2: replace implicit drift policy — implemented
+
+- Move scip-query's source-boundary rules into its `.scipquery.json`.
+- Make drift consume architecture findings instead of repository-specific hardcoded folder rules.
+- Add `drift --architecture` as a summary view.
+- Preserve unused-import drift and keep sibling-pattern deviation opt-in.
+
+### Slice 3: baselines and enforcement — implemented locally; external calibration remains
+
+- Give architecture findings stable identities.
+- Add report-only health visibility.
+- Add a narrow default diff-gate ratchet for newly introduced declared violations, backed by the shared health baseline.
+- Calibrate on scip-query, Vega 2.0, Stable Management, and structurally different external repositories before any score deduction.
+
+### Slice 4: discovery assistance
+
+- Add candidate-boundary evidence that combines paths, entry points, public surfaces, dependency neighborhoods, and co-change history.
+- Have the skill produce a reviewable architecture draft, never silently write closed rules.
+- Measure whether suggested boundaries and repairs survive maintainer review and reduce future cross-boundary churn.
+
+## Success Criteria
+
+The architecture feature is effective when:
+
+- an unconfigured repository never inherits scip-query-specific rules;
+- a configured forbidden edge is reported with concrete import evidence;
+- broad and narrow boundary edges are distinguishable;
+- large cycles are summarized without flooding the user;
+- the agent can explain why each proposed boundary exists in the running system;
+- existing debt can be ratcheted without a rewrite;
+- acting on a recommendation improves ownership or dependency direction in externally reviewed codebases;
+- the tool is willing to say “the policy is incomplete” instead of manufacturing certainty.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scip-query",
-  "version": "0.18.0",
+  "version": "0.19.1",
   "description": "Evidence and verification for AI coding agents: map code, reuse concepts, finish migrations, and gate diffs.",
   "type": "module",
   "main": "dist/index.js",
@@ -33,6 +33,10 @@
       "import": "./dist/queries/affected.js",
       "types": "./dist/queries/affected.d.ts"
     },
+    "./queries/architecture": {
+      "import": "./dist/queries/architecture.js",
+      "types": "./dist/queries/architecture.d.ts"
+    },
     "./queries/bottlenecks": {
       "import": "./dist/queries/bottlenecks.js",
       "types": "./dist/queries/bottlenecks.d.ts"

package/skills/_shared/SKILL.md

@@ -110,7 +110,7 @@ scip-query cleanup-apply # Apply a compiler-verified cleanup-plan batch to the w
 scip-query recent-duplicates # Directional duplicate candidates: recent code that re-implements established callable, React, or Vue code
 scip-query doc-drift [doc] # Stale-doc candidates: code the doc references or co-changed with kept changing after the doc stopped
 scip-query unused-params # Speculative-generality candidates: trailing parameters no body ever uses (TS/JS)
-scip-query drift [module] # Detect heuristic drift candidates: unused imports and layer violations by default; pass --patterns for pattern deviations too
+scip-query drift [module] # Detect drift candidates: unused imports and declared architecture violations; pass --architecture for boundary context
 scip-query wrapper-candidates # Find heuristic wrapper candidates only called by one consumer (high false-positive rate on codebases with intentional layering/ambient types — treat as exploration, not findings)
 scip-query passthrough-candidates # Find heuristic passthrough candidates that forward to one callee
 scip-query stale-abstractions # Find heuristic stale abstraction candidates with 0-1 consumers (high false-positive rate on codebases with intentional layering/ambient types — treat as exploration, not findings)
@@ -134,6 +134,7 @@ scip-query fan-in [symbol] # Count files referencing an exact symbol; top JSON r
 scip-query fan-out [file] # How many external symbols a file uses (or top fan-out across codebase)
 scip-query coupling [file1] [file2] # Coupling between two files, or top coupled pairs in codebase
 scip-query cycles # Detect circular dependency chains between files
+scip-query architecture # Evaluate project-owned architectural boundaries and dependency rules
 scip-query bottlenecks # Find coupling hubs: high fan-in AND high fan-out
 scip-query deep-chains # Find the longest condensed dependency-component chains
 scip-query call-graph <symbol> # Show incoming callers and outgoing callees for a symbol
@@ -145,7 +146,7 @@ scip-query call-graph <symbol> # Show incoming callers and outgoing callees for
 scip-query affected <symbol> # Transitive closure of symbols that could break if this symbol changes
 scip-query change-surface <file> # Pre-change briefing: exports, consumers, and blast-radius risk
 scip-query co-change [file] # Files that change together in git history without a dependency edge — hidden coupling candidates
-scip-query diff-gate # Gate the current diff: echo candidates, incomplete migrations, missing co-change partners, unedited twin partners (advisory), uncited doc updates, unused params, new dead symbols; exit 1 on blocking findings
+scip-query diff-gate # Gate the current diff: architecture regressions plus echo, migration, coordination, doc-drift, unused-param, and new-dead candidates; exit 1 on blocking findings
 scip-query incomplete-migration # Partially-completed extraction candidates: new helpers in the diff wired into some sites while similar un-migrated sites remain
 scip-query diff-impact # Compute changed symbols and downstream consumers from current git diff
 ```
@@ -211,7 +212,7 @@ measured precision, not by volume:
 
 ## Diff Gate Checks
 
-`diff-gate` runs nine checks (`--skip <check>` accepts any of these): `echo` (recent-duplicate-style echoes in the diff), `incomplete-migration`, `co-change-partner` (missing historically-paired file), `twin-partner` (advisory — unedited same-name twin), `coverage-contract` (a configured `coverageContracts` enumeration drifted from its ground truth — see `scip-setup`), `doc-reference` (uncited or stale doc claim), `unused-params`, `new-dead` (dead code introduced by this diff), and `baseline` (only with `--baseline`: compares against the committed `.scipquery-baseline.json`, distinct from `health --baseline`). Findings print grouped under a `Root-cause groups (N):` header before the flat list — a group's remediation usually clears every finding under it, and the same remediation may then repeat in the flat list below; that repetition is expected, not a separate issue. `--baseline` findings additionally carry an `actionTier`: `direct` (act on this finding alone), `signal` (corroborating evidence — read before acting), `support` (context only).
+`diff-gate` recognizes ten checks (`--skip <check>` accepts any of these): `echo` (recent-duplicate-style echoes in the diff), `incomplete-migration`, `co-change-partner` (missing historically-paired file), `twin-partner` (advisory — unedited same-name twin), `coverage-contract` (a configured `coverageContracts` enumeration drifted from its ground truth — see `scip-setup`), `architecture` (a declared boundary violation absent from the shared baseline), `doc-reference` (uncited or stale doc claim), `unused-params`, `new-dead` (dead code introduced by this diff), and `baseline` (only with `--baseline`: compares all non-architecture health identities against the committed `.scipquery-baseline.json`, distinct from `health --baseline`). The architecture check runs by default only when enforceable architecture rules and a baseline exist; it uses that same file without running the full health suite. Findings print grouped under a `Root-cause groups (N):` header before the flat list — a group's remediation usually clears every finding under it, and the same remediation may then repeat in the flat list below; that repetition is expected, not a separate issue. Baseline-backed findings additionally carry an `actionTier`: `direct` (act on this finding alone), `signal` (corroborating evidence — read before acting), `support` (context only).
 
 ## Postchecks
 

package/skills/scip-conductor/SKILL.md

@@ -24,7 +24,7 @@ Load shared mechanics from [`../_shared/SKILL.md`](../_shared/SKILL.md).
 | Command | Purpose | When |
 | --- | --- | --- |
 | `scip-query plan-context <target>` | Pre-edit planning context for a symbol, file, or module | Anchor each phase's step before delegating it. |
-| `scip-query diff-gate --json` | Gate the current diff: echo candidates, incomplete migrations, missing co-change partners, unedited twin partners (advisory), uncited doc updates, unused params, new dead symbols; exit 1 on blocking findings | Verify a handoff before accepting it and before closing the program. |
+| `scip-query diff-gate --json` | Gate the current diff: architecture regressions plus echo, migration, coordination, doc-drift, unused-param, and new-dead candidates; exit 1 on blocking findings | Verify a handoff before accepting it and before closing the program. |
 | `scip-query health --json` | Composite codebase health report with prioritized action list | Pre-register or check a program-level health benchmark. |
 
 Use this shortlist first. Open [`../_shared/SKILL.md`](../_shared/SKILL.md) only when it is insufficient.

package/skills/scip-directory-architecture/SKILL.md

@@ -10,8 +10,16 @@ commands:
     when: "Inventory evidence: files with overlapping dependency profiles."
   - template: "scip-query cycles"
     when: "Inventory evidence: circular dependency chains between files."
+  - template: "scip-query architecture --json"
+    when: "Measure configured boundaries, actual dependency traffic, forbidden edges, reciprocal pairs, and boundary cycles."
+  - template: "scip-query drift --architecture"
+    when: "Review direct drift findings together with boundary coverage and architecture signals."
   - template: "scip-query co-change --json --full"
     when: "Inventory evidence: hidden file-level coupling from git history."
+  - template: "scip-query health --write-baseline"
+    when: "Record reviewed existing debt before enabling architecture regression enforcement."
+  - template: "scip-query diff-gate"
+    when: "Verify that the current diff introduces no new declared architecture violation."
   - template: "scip-query config-validate --json"
     when: "Implement a slice: validate locality config after a move."
 ---
@@ -31,7 +39,11 @@ Load shared mechanics from [`../_shared/SKILL.md`](../_shared/SKILL.md).
 | `scip-query locality-candidates --json --full` | Find directory-locality and ancestry candidates from consumer ownership | Inventory evidence: directory-locality candidates from consumer ownership. |
 | `scip-query similar-files --full --json` | Find heuristic similar-file candidates from dependency profiles | Inventory evidence: files with overlapping dependency profiles. |
 | `scip-query cycles` | Detect circular dependency chains between files | Inventory evidence: circular dependency chains between files. |
+| `scip-query architecture --json` | Evaluate project-owned architectural boundaries and dependency rules | Measure configured boundaries, actual dependency traffic, forbidden edges, reciprocal pairs, and boundary cycles. |
+| `scip-query drift --architecture` | Detect drift candidates: unused imports and declared architecture violations; pass --architecture for boundary context | Review direct drift findings together with boundary coverage and architecture signals. |
 | `scip-query co-change --json --full` | Files that change together in git history without a dependency edge — hidden coupling candidates | Inventory evidence: hidden file-level coupling from git history. |
+| `scip-query health --write-baseline` | Composite codebase health report with prioritized action list | Record reviewed existing debt before enabling architecture regression enforcement. |
+| `scip-query diff-gate` | Gate the current diff: architecture regressions plus echo, migration, coordination, doc-drift, unused-param, and new-dead candidates; exit 1 on blocking findings | Verify that the current diff introduces no new declared architecture violation. |
 | `scip-query config-validate --json` | Validate .scipquery.json, including structured suppressions and declared coupling groups | Implement a slice: validate locality config after a move. |
 
 Use this shortlist first. Open [`../_shared/SKILL.md`](../_shared/SKILL.md) only when it is insufficient.
@@ -41,6 +53,16 @@ Use this shortlist first. Open [`../_shared/SKILL.md`](../_shared/SKILL.md) only
 
 An ownership boundary is a folder, package, module, or convention that groups code around one stable responsibility.
 
+A dependency edge points from code that relies on something to the code it relies on. For imports, `A -> B` means A imports B.
+
+A forbidden edge is an actual cross-boundary dependency rejected by an explicit project rule. Directory distance or an unusual import does not make an edge forbidden by itself.
+
+A layer is a responsibility ordered by dependency direction, such as presentation depending on application. A subsystem is a responsibility that owns an end-to-end capability, such as authentication or rendering. A package is a publication or build unit. A service is an independently running unit. Do not force all four into one layer hierarchy.
+
+A reciprocal dependency is dependency traffic in both directions between two boundaries. It is a review signal because the boundaries exert mutual change pressure, not proof that either import is wrong.
+
+An architecture ratchet is an enforcement rule that records existing violations while preventing new ones, allowing a large codebase to improve without a speculative rewrite.
+
 A target structure is a proposed future layout that expresses an ownership model, not merely a prettier tree.
 
 A migration slice is the smallest set of file moves and import updates that can be verified independently.
@@ -55,6 +77,8 @@ A slop codebase is a codebase whose files are arranged by accident, convenience,
 4. Do not reward generic `shared` unless the shared concept has a name, owner, and cross-boundary consumers.
 5. For messy repos, produce a discovery map and decisions instead of pretending the target is obvious.
 6. Prefer small verified moves.
+7. Configure descriptive boundaries before closing dependency rules.
+8. Treat graph shape as evidence about responsibilities, never as a substitute for identifying them.
 
 ## Workflow
 
@@ -77,6 +101,8 @@ scip-query change-surface <file>
 scip-query plan-context <file-or-symbol>
 scip-query locality-candidates --json --full
 scip-query cycles
+scip-query architecture --json
+scip-query drift --architecture
 scip-query co-change
 scip-query similar-files --min-similarity 0.6 --min-deps 3
 scip-query similar-chains --min-similarity 0.5
@@ -98,7 +124,66 @@ Classify each candidate:
 
 This step is complete only when mature, emerging, and accidental boundaries are separated.
 
-### 4. Propose structure or decisions
+### 4. Build a descriptive architecture model
+
+For a large existing codebase, identify real system units before calling them layers. Inventory:
+
+- workspace packages and public exports;
+- applications, services, and deployable entry points;
+- domain capabilities and end-to-end subsystems;
+- persistence, network, rendering, compiler, and other technical responsibilities;
+- tests, routes, contracts, and ownership or architecture documentation;
+- dependency and co-change evidence that shows which files already move as a unit.
+
+Add mature boundary path patterns to `.scipquery.json` without `allowedDependencies` rows first:
+
+```json
+{
+  "architecture": {
+    "boundaries": [
+      { "name": "domain", "paths": ["src/domain/**"] },
+      { "name": "runtime", "paths": ["src/runtime/**"] }
+    ]
+  }
+}
+```
+
+Then run:
+
+```bash
+scip-query config-validate --json
+scip-query architecture --json
+```
+
+Use unmapped and ambiguous files to repair boundary membership. Use actual boundary edges, reciprocal pairs, and strongly connected groups to test whether the names describe real separation.
+
+This step is complete only when every configured boundary has a stated responsibility and the mapping gaps are understood.
+
+### 5. Declare only supported dependency rules
+
+An `allowedDependencies` row is closed: an outgoing target omitted from a present row is forbidden. A missing row makes no dependency claim.
+
+```json
+{
+  "architecture": {
+    "boundaries": [
+      { "name": "domain", "paths": ["src/domain/**"] },
+      { "name": "runtime", "paths": ["src/runtime/**"] }
+    ],
+    "allowedDependencies": {
+      "domain": [],
+      "runtime": ["domain"]
+    },
+    "requireAcyclic": true
+  }
+}
+```
+
+For each closed row, record the evidence for its intended direction. Do not copy the current dependency graph into the allow-list merely to obtain zero findings. Leave emerging or disputed rows undeclared.
+
+This step is complete only when every forbidden edge is understood as either implementation debt, a false boundary, or a policy mistake.
+
+### 6. Propose structure or decisions
 
 Use this shape:
 
@@ -108,6 +193,10 @@ Use this shape:
 ## Scope
 ## Current Structure Map
 ## Boundary Maturity
+## Descriptive Architecture Model
+## Dependency Rules
+## Forbidden-Edge Ledger
+## Reciprocal and Cycle Review
 ## Target Structure
 ## Move Ledger
 ## Locality Config
@@ -120,7 +209,29 @@ List no-move decisions when broad consumers, route/package/contract surfaces, in
 
 This step is complete only when every proposed move has a reason and verification path.
 
-### 5. Implement one slice when asked
+### 7. Ratchet, then implement one slice when asked
+
+For a large repository with existing violations, review the direct findings and
+write the shared health baseline:
+
+```bash
+scip-query drift --architecture
+scip-query health --write-baseline
+```
+
+The baseline records stable architecture identities by boundary pair, not by
+whichever example file happens to sort first. The default `scip-query
+diff-gate` architecture check then compares only architecture identities; it
+does not run every health detector. `diff-gate --baseline` remains the opt-in
+full health ratchet and does not duplicate architecture findings.
+
+Commit `.scipquery-baseline.json` with `.scipquery.json`. A missing baseline
+causes the architecture gate to report that enforcement is not enabled; it
+does not silently treat the current graph as accepted.
+
+Prefer inspecting the least-broad edge inside a boundary cycle first, but
+determine whether the repair is a move, dependency inversion, named shared
+contract, boundary merge, or policy correction.
 
 Before editing, state files to move, imports/exports/tests/docs to update, expected verification, and rollback risk. Then move the smallest high-confidence slice and run:
 
@@ -135,6 +246,9 @@ Also run project tests or typecheck for the affected workspace. If `.scipquery.j
 ```bash
 scip-query config-validate
 scip-query locality-candidates --json --full
+scip-query architecture --json
+scip-query drift --architecture
+scip-query diff-gate
 ```
 
 Then invoke `scip-verify`. The implementation is complete only when imports, tests, locality signals, and verification are checked.

package/skills/scip-maintainability/SKILL.md

@@ -12,8 +12,8 @@ commands:
     when: "Map evidence: exports, consumers, and blast-radius risk."
   - template: "scip-query affected <symbol>"
     when: "Map evidence: transitive consumers of a candidate symbol."
-  - template: "scip-query drift --patterns"
-    when: "Map evidence: layer violations and pattern deviations as probes (--patterns is off by default and near-zero precision; treat hits as leads, not findings)."
+  - template: "scip-query drift --patterns --architecture"
+    when: "Map evidence: declared architecture violations plus boundary and pattern signals; treat opt-in pattern hits as leads, not findings."
 ---
 
 # scip-maintainability
@@ -32,7 +32,7 @@ Load shared mechanics from [`../_shared/SKILL.md`](../_shared/SKILL.md).
 | `scip-query surface <scope>` | What symbols consumers actually use from this module | Map evidence: what consumers actually use from the scope. |
 | `scip-query change-surface <file>` | Pre-change briefing: exports, consumers, and blast-radius risk | Map evidence: exports, consumers, and blast-radius risk. |
 | `scip-query affected <symbol>` | Transitive closure of symbols that could break if this symbol changes | Map evidence: transitive consumers of a candidate symbol. |
-| `scip-query drift --patterns` | Detect heuristic drift candidates: unused imports and layer violations by default; pass --patterns for pattern deviations too | Map evidence: layer violations and pattern deviations as probes (--patterns is off by default and near-zero precision; treat hits as leads, not findings). |
+| `scip-query drift --patterns --architecture` | Detect drift candidates: unused imports and declared architecture violations; pass --architecture for boundary context | Map evidence: declared architecture violations plus boundary and pattern signals; treat opt-in pattern hits as leads, not findings. |
 
 Use this shortlist first. Open [`../_shared/SKILL.md`](../_shared/SKILL.md) only when it is insufficient.
 <!-- END GENERATED SKILL COMMANDS -->

package/skills/scip-query/SKILL.md

@@ -23,7 +23,7 @@ Load shared mechanics from [`../_shared/SKILL.md`](../_shared/SKILL.md) when you
 | --- | --- | --- |
 | `scip-query status --capabilities` | Show index status for this project | Before routing: confirm the index is fresh. |
 | `scip-query plan-context <target>` | Pre-edit planning context for a symbol, file, or module | Default loop: anchor a plan for the routed skill. |
-| `scip-query diff-gate --json` | Gate the current diff: echo candidates, incomplete migrations, missing co-change partners, unedited twin partners (advisory), uncited doc updates, unused params, new dead symbols; exit 1 on blocking findings | Default loop: the loop is complete only when this passes or is explained. |
+| `scip-query diff-gate --json` | Gate the current diff: architecture regressions plus echo, migration, coordination, doc-drift, unused-param, and new-dead candidates; exit 1 on blocking findings | Default loop: the loop is complete only when this passes or is explained. |
 
 Use this shortlist first. Open [`../_shared/SKILL.md`](../_shared/SKILL.md) only when it is insufficient.
 <!-- END GENERATED SKILL COMMANDS -->

package/skills/scip-twin-drift/SKILL.md

@@ -29,7 +29,7 @@ Load shared mechanics from [`../_shared/SKILL.md`](../_shared/SKILL.md).
 | `scip-query duplicate-bodies --json --full` | Find exact duplicate small-body candidates across files | Cross-check: IDENTICAL groups are duplicate-bodies' job, not this skill's. |
 | `scip-query code <symbol>` | Read the source code for a symbol (bounded to its definition range) | Classify a divergent group: read every member's body. |
 | `scip-query refs <symbol>` | Find all files referencing a symbol | Pick the canonical twin: consumer count per member. |
-| `scip-query diff-gate --json` | Gate the current diff: echo candidates, incomplete migrations, missing co-change partners, unedited twin partners (advisory), uncited doc updates, unused params, new dead symbols; exit 1 on blocking findings | Verify: the twin-partner check must not flag a one-sided fix. |
+| `scip-query diff-gate --json` | Gate the current diff: architecture regressions plus echo, migration, coordination, doc-drift, unused-param, and new-dead candidates; exit 1 on blocking findings | Verify: the twin-partner check must not flag a one-sided fix. |
 
 Use this shortlist first. Open [`../_shared/SKILL.md`](../_shared/SKILL.md) only when it is insufficient.
 <!-- END GENERATED SKILL COMMANDS -->

package/skills/scip-verify/SKILL.md

@@ -30,7 +30,7 @@ Load shared mechanics from [`../_shared/SKILL.md`](../_shared/SKILL.md).
 | `scip-query doctor` | Diagnose config, index freshness, dependency readiness, and project capabilities | Prove the workspace: index freshness and dependency readiness. |
 | `scip-query status --capabilities` | Show index status for this project | Prove the workspace: which evidence and verification capabilities are available. |
 | `scip-query diff-impact --json` | Compute changed symbols and downstream consumers from current git diff | Assess the diff: changed symbols and downstream consumers. |
-| `scip-query diff-gate --json` | Gate the current diff: echo candidates, incomplete migrations, missing co-change partners, unedited twin partners (advisory), uncited doc updates, unused params, new dead symbols; exit 1 on blocking findings | Run the gate: the primary blocker for diff-specific risk. |
+| `scip-query diff-gate --json` | Gate the current diff: architecture regressions plus echo, migration, coordination, doc-drift, unused-param, and new-dead candidates; exit 1 on blocking findings | Run the gate: the primary blocker for diff-specific risk. |
 | `scip-query health --baseline` | Composite codebase health report with prioritized action list | Check health: compare findings against the committed baseline. |
 | `scip-query doc-drift --json --full` | Stale-doc candidates: code the doc references or co-changed with kept changing after the doc stopped | Check docs: run when docs, AGENTS.md, or command surfaces changed. |
 

package/dist/chunk-2GX3TNOW.js

@@ -1,38 +0,0 @@
-import{b as le,c as O,d as T,e as H,k as be,l as ye}from"./chunk-OM6JHEW3.js";import{d as re,e as de,f as $,g as ue,l as fe,m as pe}from"./chunk-PZV2PGBR.js";import{D as me,n as ce,x as j}from"./chunk-4MFMTEJ4.js";import{a as te}from"./chunk-QEIGJJBC.js";import{d as ge,e as he}from"./chunk-MTDBHTSF.js";import{e as N,g as oe,s as ie,t as P,y as ae,z as se}from"./chunk-7XP7ZRSI.js";import{k as E,m as ee,p as ne}from"./chunk-JLZUM476.js";import{B as D,c as q}from"./chunk-TLTLJ4SW.js";import{a as Z}from"./chunk-64MNV6AB.js";import{c as z,d as Q,g as G,h as x,j as Y,l as K,q as X,s as _,y as F}from"./chunk-M2TRDR25.js";function Rn(e,n,t={}){let o=Me(e,[n],{additive:t.additive,semantic:t.semantic}),i=t.callableOnly?(o.get(n.symbolId)??[]).filter(s=>oe(s.symbol)||s.source==="ast-callsite"):o.get(n.symbolId)??[];return typeof t.limit=="number"?i.slice(0,t.limit):i}function Ce(e,n,t={}){return U(e,[n],t).get(n.symbolId)??[]}function U(e,n,t={}){let o=De(e)?Ee(e,n,{semantic:t.semantic!==!1}):ke(e);return typeof t.limit!="number"?new Map(n.map(i=>[i.symbolId,o.get(i.symbolId)??[]])):new Map(n.map(i=>[i.symbolId,(o.get(i.symbolId)??[]).slice(0,t.limit)]))}var Le=Q("caller-rows",{clearGroups:["whole-project"]}),_e=2e4;function De(e){return(e.get("SELECT COUNT(*) AS count FROM global_symbols")?.count??0)>_e}function ke(e){return Le.get(e,()=>{let n=P(e),t=Me(e,n),o=new Map;for(let a of n)o.set(a.symbol,a.symbolId);let i=new Map,s=new Map;for(let a of n){let r=t.get(a.symbolId);if(!(!r||r.length===0))for(let d of r){let c=o.get(d.symbol);if(c===void 0||c===a.symbolId)continue;let m=i.get(c);m||(m=[],i.set(c,m),s.set(c,new Set));let b=`${a.symbol}|${a.relativePath}`;s.get(c).has(b)||(s.get(c).add(b),m.push({symbol:a.symbol,file:a.relativePath,source:"caller-map-inversion"}))}}return i})}function Ee(e,n,t){let o=t.semantic?n.flatMap(r=>{let d=ve(e,r);return d?[d]:[]}):[],i=new Map(o.map(r=>[r.symbolId,r])),s=fe(e,o),a=new Map;for(let r of n){let d=[],c=new Set,m=p=>{if(p.symbol===r.symbol)return;let l=`${p.symbol}|${p.file}`;c.has(l)||(c.add(l),d.push(p))};for(let p of ye(e,r))p.file!==r.relativePath&&m({symbol:p.enclosingSymbol??p.file,file:p.file,source:"resolved-reference"});let b=i.get(r.symbolId);if(b)for(let p of s.get(b.symbolId)??[]){if(p.file===r.relativePath||e.isIgnored(p.file))continue;let l=se(ie(e,p.file),p.line);m({symbol:l?.symbol??p.file,file:p.file,source:"semantic-reference"})}a.set(r.symbolId,d)}return a}function ve(e,n){let t=ge().join(", "),o=he().join(", ");return e.get(`SELECT
-       d.id AS documentId,
-       gs.id AS symbolId,
-       gs.symbol,
-       d.relative_path AS relativePath,
-       COALESCE(der.start_line, c.start_line) AS startLine,
-       COALESCE(der.end_line, c.end_line) AS endLine,
-       COALESCE(gs.display_name, '') AS leaf,
-       NULL AS parentTypeName,
-       CASE WHEN gs.kind IN (${t}) OR gs.symbol LIKE '%().' THEN 1 ELSE 0 END AS isFunctionLike,
-       CASE WHEN gs.kind IN (${o}) THEN 1 ELSE 0 END AS isTypeLike,
-       gs.kind AS kind,
-       gs.documentation AS documentation,
-       gs.enclosing_symbol AS enclosingSymbol
-     FROM global_symbols gs
-     LEFT JOIN defn_enclosing_ranges der ON der.symbol_id = gs.id
-     LEFT JOIN chunks c ON c.document_id = der.document_id
-     JOIN documents d ON d.id = COALESCE(der.document_id, c.document_id)
-     WHERE gs.id = ?
-     LIMIT 1`,n.symbolId)??null}function Me(e,n,t={}){if(n.length===0)return new Map;let o=t.additive??!1,i=[],s=[];for(let m of n)D(m.relativePath)&&E(e,m.relativePath)!==null?i.push(m):s.push(m);let a=new Map,r=new Map,d=m=>{for(let[b,p]of m){let l=a.get(b);l||(l=[],a.set(b,l));let g=r.get(b);g||(g=new Set,r.set(b,g));for(let R of p){let C=`${R.symbol}|${R.chunkId}`;g.has(C)||(g.add(C),l.push(R))}}};i.length>0&&d(Te(e,i)),t.semantic!==!1&&d(Ke(Ae(e,n)));let c=o?n:s;return c.length>0&&d(Be(e,c)),a}function Ae(e,n){let t=X(),o=new Map,i=ue(e,n),s=[],a=[],r=0,d=0,c=0,m=0,b=0,p=0,l=0;for(let{definition:f,callees:u}of i.hits)b+=1,u.length>0&&(p+=1,l+=u.length,o.set(f.symbolId,u));let g=xe(e,i.hits);if(g.entries.length>0&&_("semantic.callees.prefetch-cache-write",()=>K(e,g.entries),()=>({entries:g.entries.length,sourceMissing:g.sourceMissing,skippedUnsupportedLanguage:g.skippedUnsupportedLanguage})),_("semantic.callees.cache-scan",()=>{for(let[f,u]of de(i.misses)){if(!j(f)){t&&(r+=u.length);continue}let h=F(e,f);if(!h){t&&(d+=u.length),a.push(...u);continue}let k=x(e,f,h),I=Re(e,f);if(!I){a.push(...u);continue}let B=Y(e,f,k,I);for(let y of u){let S=B.get(y.symbol)??null;if(S!==null){let w=Ne(S);if(w){t&&(c+=1),w.length>0&&o.set(y.symbolId,w);continue}t&&(m+=1)}s.push({def:y,contentHash:k,depsDigest:I})}}},()=>({definitions:n.length,skippedUnsupportedLanguage:r,sourceMissing:d,cacheHits:c,parseFailures:m,misses:s.length,unkeyed:a.length,inMemoryHits:b,inMemoryRows:p,inMemoryCalleeCount:l,resultRows:o.size})),s.length===0&&a.length===0)return o;let R=[...a,...s.map(f=>f.def)],C=0,v=_("semantic.callees.compute-misses",()=>{let f=pe(e,R);return C=f.size,f},()=>({definitions:R.length,misses:s.length,unkeyed:a.length,rows:C}));for(let[f,u]of v)o.set(f,u);let M=s.filter(f=>$(e).capability("semantic-callees",f.def.relativePath).available).map(f=>({relativePath:f.def.relativePath,symbol:f.def.symbol,contentHash:f.contentHash,depsDigest:f.depsDigest,payload:JSON.stringify(v.get(f.def.symbolId)??[])}));return M.length>0?_("semantic.callees.cache-write",()=>K(e,M),()=>({entries:M.length})):_("semantic.callees.cache-write-skip",()=>{},()=>({reason:"provider-unavailable",misses:s.length})),o}function xe(e,n){let t=[],o=new Map,i=0,s=0;for(let{definition:a,callees:r}of n){if(!j(a.relativePath)){s+=1;continue}if(!o.has(a.relativePath)){let c=F(e,a.relativePath),m=c?Re(e,a.relativePath):null;o.set(a.relativePath,c&&m?{contentHash:x(e,a.relativePath,c),depsDigest:m}:null)}let d=o.get(a.relativePath);if(!d){i+=1;continue}t.push({relativePath:a.relativePath,symbol:a.symbol,contentHash:d.contentHash,depsDigest:d.depsDigest,payload:JSON.stringify(r)})}return{entries:t,sourceMissing:i,skippedUnsupportedLanguage:s}}var Fe="typescript-callees-v1";function Re(e,n){let t=j(n);if(t==="typescript")return me(e,n,Fe)?.key??null;let o=Oe(e,n);return t==="rust"?G(JSON.stringify({kind:"semantic-callees",language:t,engine:ce(e.config.projectRoot),positionMapping:"nearby-leaf-v1",depsDigest:o})):o}function Ne(e){try{return JSON.parse(e)}catch{return null}}var Pe=z("semantic-deps-digest",{clearGroups:["whole-project","source-file"]});function Oe(e,n){return Pe.get(e,n,()=>{let o=[...te(e).get(n)??[]].sort().map(i=>`${i}:${x(e,i,F(e,i))}`);return G(o.join("|"))})}function Te(e,n){let t=new Map,o=He(n,t),i=H(e);for(let[s,a]of o){let r=E(e,s);if(!r)continue;let d=ae(a);for(let c of r){let m=d.get(c.line);if(!m)continue;let b=je(e,s,i,c);b&&b.symbol!==m.symbol&&t.get(m.symbolId).push({symbol:b.symbol,file:b.file,chunkId:c.line,source:"ast-callsite"})}}return t}function He(e,n){let t=new Map;for(let o of e){let i=t.get(o.relativePath);i?i.push(o):t.set(o.relativePath,[o]),n.set(o.symbolId,[])}for(let o of t.values())o.sort((i,s)=>i.endLine-i.startLine-(s.endLine-s.startLine));return t}function je(e,n,t,o){let i=O(n,t.get(o.calleeLeaf)??[]);if(i.length===0)return null;let s=$e(e,n,i,o.calleeQualifier);return s||T(e,n,i,o.memberAccess)}function $e(e,n,t,o){if(!o||D(n)!=="clojure")return null;let s=ne(e,n).filter(a=>a.kind==="namespace"&&a.localName===o&&a.sourcePath).map(a=>a.sourcePath);for(let a of s){let r=t.find(d=>q(a,d.file));if(r)return r}return t.find(a=>/`([^`]+)`\//.exec(a.symbol)?.[1]===o)??null}function Be(e,n){if(n.length===0)return new Map;let o=J(n.map(l=>l.documentId)).flatMap(l=>e.all(`SELECT c.document_id, c.id AS chunk_id, c.start_line, c.end_line, m.symbol_id
-     FROM mentions m
-     JOIN chunks c ON m.chunk_id = c.id
-     WHERE m.role != 1
-       AND c.document_id IN (${l.map(()=>"?").join(",")})`,...l)),i=new Map;for(let l of o)i.has(l.document_id)||i.set(l.document_id,[]),i.get(l.document_id).push(l);let a=J(o.map(l=>l.symbol_id)).flatMap(l=>e.all(`SELECT gs.id AS symbol_id, gs.symbol,
-            COALESCE(der.document_id, def_chunk.document_id) AS document_id
-     FROM global_symbols gs
-     LEFT JOIN defn_enclosing_ranges der ON der.symbol_id = gs.id
-     LEFT JOIN (
-       SELECT m.symbol_id, MIN(c.document_id) AS document_id
-       FROM mentions m
-       JOIN chunks c ON m.chunk_id = c.id
-       WHERE m.role = 1
-         AND m.symbol_id IN (${l.map(()=>"?").join(",")})
-       GROUP BY m.symbol_id
-     ) def_chunk ON def_chunk.symbol_id = gs.id
-     WHERE gs.id IN (${l.map(()=>"?").join(",")})`,...l,...l)),r=J([...n.map(l=>l.documentId),...a.flatMap(l=>l.document_id===null?[]:[l.document_id])]),d=new Map(r.flatMap(l=>e.all(`SELECT id, relative_path FROM documents
-       WHERE id IN (${l.map(()=>"?").join(",")})`,...l).map(g=>[g.id,g.relative_path]))),c=new Map;for(let l of a)c.has(l.symbol_id)||c.set(l.symbol_id,{symbol:l.symbol,file:l.document_id!==null?d.get(l.document_id)??"":""});let m=new Map,b=d,p=Ge(n);for(let[l,g]of p){let C=[...i.get(l)??[]].sort((u,h)=>u.start_line-h.start_line||u.end_line-h.end_line),v=[...g].sort((u,h)=>u.startLine-h.startLine||u.endLine-h.endLine),M=new Set,f=0;for(let u of v){for(;f<C.length&&C[f].start_line<=u.endLine;)M.add(C[f]),f+=1;for(let y of M)y.end_line<u.startLine&&M.delete(y);let h=new Set,k=[],I=null,B=()=>{if(I)return I;let y=b.get(u.documentId)??"",S=new Set;if(y){let w=le(e,y),A=Math.max(0,u.startLine),V=Math.min(w.length-1,u.endLine);for(let L=A;L<=V;L+=1)for(let we of w[L])S.add(we)}return I=S,S};for(let y of M){if(y.symbol_id===u.symbolId)continue;let S=c.get(y.symbol_id);if(!S)continue;if(!(y.start_line>=u.startLine&&y.end_line<=u.endLine)){if(!(y.start_line<=u.endLine&&y.end_line>=u.startLine))continue;let L=N(S.symbol);if(!L||!B().has(L))continue}let A=`${S.symbol}|${y.chunk_id}`;h.has(A)||(h.add(A),k.push({...S,chunkId:y.chunk_id,source:"scip-chunk"}))}m.set(u.symbolId,k)}}return m}var Se=500;function J(e){let n=[...new Set(e)],t=[];for(let o=0;o<n.length;o+=Se)t.push(n.slice(o,o+Se));return t}function Ge(e){let n=new Map;for(let t of e){let o=n.get(t.documentId);o?o.push(t):n.set(t.documentId,[t])}return n}function Ke(e){let n=new Map;for(let[t,o]of e){let i=[];for(let s of o)i.push({symbol:s.symbol,file:s.file,chunkId:-1,source:"semantic-callee"});n.set(t,i)}return n}function Ie(e,n,t={}){let o=new Map;if(n&&n.length===0)return o;let i=Z(e,{includeIgnored:!1}),s=H(e),a=n??P(e),r=new Set(a.map(c=>c.symbolId)),d=Ye(a);if(Je(e,o,i,s,r,d),Ue(e,o,a,r),Qe(e,o,i,s,r,d),t.semantic!==!1){let c=$(e);qe(o,c.callerMap(Ze(a)))}return o}function Je(e,n,t,o,i,s){for(let a of t){if(!D(a))continue;let r=E(e,a);if(r)for(let d of r){if(s&&!s.has(d.calleeLeaf))continue;let c=O(a,o.get(d.calleeLeaf)??[]);if(!c||c.length===0)continue;let m=T(e,a,c,d.memberAccess);m&&i.has(m.symbolId)&&m.file!==a&&W(n,m.symbolId,a)}}}function Ue(e,n,t,o){let i=Ve(t);for(let s of We(e,o))e.isIgnored(s.relative_path)||ze(s,i.get(s.symbol_id))||W(n,s.symbol_id,s.relative_path)}function We(e,n){return re(e,n?[...n]:void 0)}function Ve(e){let n=new Map;for(let t of e)n.set(t.symbolId,{docId:t.documentId,startLine:t.startLine,endLine:t.endLine});return n}function ze(e,n){return!!n&&n.docId===e.document_id&&e.chunk_start>=n.startLine&&e.chunk_end<=n.endLine}function Qe(e,n,t,o,i,s){for(let a of t){if(D(a)!=="rust")continue;let r=ee(e,a,{includeRustAttributeNames:!0});if(r.length!==0)for(let{name:d}of r){if(s&&!s.has(d))continue;let c=o.get(d);if(c)for(let m of c)i.has(m.symbolId)&&m.file!==a&&W(n,m.symbolId,a)}}}function W(e,n,t){let o=e.get(n);o||(o=new Set,e.set(n,o)),o.add(t)}function Ye(e){let n=new Set;for(let t of e){let o="leaf"in t&&typeof t.leaf=="string"?t.leaf:"symbol"in t&&typeof t.symbol=="string"?N(t.symbol):"";o&&n.add(o)}return n.size>0?n:null}function Ze(e){return e.filter(n=>"relativePath"in n&&"symbol"in n&&"leaf"in n)}function qe(e,n){for(let[t,o]of n){let i=e.get(t);i||(i=new Set,e.set(t,i));for(let s of o)i.add(s)}}function Pn(e,n,t={}){return Ce(e,n,t)}function On(e,n,t={}){return U(e,n,t)}function Xe(e,n,t={}){return Ie(e,n,t)}function en(e,n,t={}){return be(e,n,t)}function Tn(e,n,t={}){let o=Xe(e,n,{semantic:t.semantic});return t.sourceFallback===!1?o:nn(o,en(e,n))}function nn(e,n){let t=new Map;for(let[o,i]of e)t.set(o,new Set(i));for(let[o,i]of n){let s=t.get(o)??new Set;for(let a of i)s.add(a);t.set(o,s)}return t}export{Rn as a,Me as b,Pn as c,On as d,Xe as e,en as f,Tn as g,nn as h};
-//# sourceMappingURL=chunk-2GX3TNOW.js.map

package/dist/chunk-45XOH33S.js

@@ -1,2 +0,0 @@
-import{a as C}from"./chunk-L2RE5P3X.js";import{m as v}from"./chunk-OM6JHEW3.js";import{f as O,i as x,m as T}from"./chunk-PZV2PGBR.js";import{d as A}from"./chunk-7XP7ZRSI.js";import{f as b}from"./chunk-JLZUM476.js";import{B as g}from"./chunk-TLTLJ4SW.js";function H(e,n={}){let{samples:o=50,scope:r,maxDisagreements:u=5}=n,l=new C(e),a=B(l.productionCallableDefinitions({scope:r,minLoc:2,requireFunctionLikeSymbol:!0}),o),c=K(e,a);if(a.length===0||!c)return{available:!1,sampleSize:a.length,oracleCoverage:0,scores:[],topDisagreements:[]};let t={references:P(),callees:P()},i=[],f=0,m=c==="semantic"?T(e,a):new Map,I=c==="source"?E(e,l,a):null;for(let s of a){let p=S(s,c==="semantic"?x(e,s).map(d=>d.file):[...I?.referencesBySymbolId.get(s.symbolId)??[]]),j=S(s,c==="semantic"?(m.get(s.symbolId)??[]).map(d=>d.file):[...I?.calleesBySymbolId.get(s.symbolId)??[]]);f+=1;let L=S(s,v(e,s).map(d=>d.file)),k=S(s,(l.calleeMap([s],{semantic:!1}).get(s.symbolId)??[]).map(d=>d.file)),w=y(c,"references"),R=y(c,"callees");Q(t.references,s,"references",L,p,w,i),Q(t.callees,s,"callees",k,j,R,i)}return i.sort((s,p)=>p.cheapOnly.length+p.oracleOnly.length-(s.cheapOnly.length+s.oracleOnly.length)),{available:!0,sampleSize:a.length,oracleCoverage:a.length>0?D(f/a.length):0,oracleKind:c,scores:["references","callees"].map(s=>F(s,t[s],c)),topDisagreements:i.slice(0,u)}}function P(){return{comparedSymbols:0,agreed:0,cheapTotal:0,oracleTotal:0,skippedOraclePartial:0}}function B(e,n){let o=[...e].sort((l,a)=>l.symbolId-a.symbolId);if(o.length<=n)return o;let r=o.length/n,u=[];for(let l=0;l<n;l++)u.push(o[Math.floor(l*r)]);return u}function K(e,n){let o=n[0];if(!o)return null;if(h(e,o))return"source";try{if(O(e).capability("semantic-references",o.relativePath).available)return"semantic"}catch{}return n.some(r=>h(e,r))?"source":null}function S(e,n){let o=new Set;for(let r of n)r!==e.relativePath&&o.add(r);return o}function Q(e,n,o,r,u,l,a){if(!l&&u.size===0){e.skippedOraclePartial+=1;return}e.comparedSymbols+=1,e.cheapTotal+=r.size,e.oracleTotal+=u.size;let c=[],t=[];for(let i of r)u.has(i)?e.agreed+=1:c.push(i);for(let i of u)r.has(i)||t.push(i);(c.length>0||t.length>0)&&a.push({symbol:A(n.symbol),question:o,cheapOnly:c,oracleOnly:t})}var z={references:!0,callees:!1};function F(e,n,o){let r=n.oracleTotal>0?n.agreed/n.oracleTotal:1,u=n.cheapTotal-n.agreed,l=y(o,e);return{question:e,comparedSymbols:n.comparedSymbols,precision:l&&n.cheapTotal>0?D(n.agreed/n.cheapTotal):null,recall:D(r),unverified:u,skippedOraclePartial:n.skippedOraclePartial}}function y(e,n){return e==="semantic"?z[n]:!1}function h(e,n){return g(n.relativePath)==="clojure"&&b(e,n.relativePath)!==null}function E(e,n,o){let r=new Map,u=new Map,l=o.filter(t=>h(e,t)),a=new Map;for(let t of l){let i=a.get(t.leaf)??[];i.push(t),a.set(t.leaf,i)}for(let t of n.sourceFiles()){if(g(t)!=="clojure")continue;let i=b(e,t);if(i)for(let f of i.fileIdentifiers)for(let m of a.get(f)??[])M(r,m.symbolId,t)}let c=new Map;for(let t of n.scopedDefinitions()){if(g(t.relativePath)!=="clojure")continue;let i=c.get(t.leaf)??[];i.push(t),c.set(t.leaf,i)}for(let t of l){let i=b(e,t.relativePath);if(i){for(let f of i.callSites)if(!(f.line<t.startLine||f.line>t.endLine))for(let m of c.get(f.calleeLeaf)??[])M(u,t.symbolId,m.relativePath)}}return{referencesBySymbolId:r,calleesBySymbolId:u}}function M(e,n,o){let r=e.get(n);if(r){r.add(o);return}e.set(n,new Set([o]))}function D(e){return Math.round(e*1e3)/1e3}export{H as a};
-//# sourceMappingURL=chunk-45XOH33S.js.map