scip-query 0.20.0 → 0.21.0

package/skills/scip-plan/SKILL.md

@@ -1,68 +1,86 @@
 ---
 name: scip-plan
-description: Use before, during, AND after non-trivial work: plan a change, migration, or refactor; assess what breaks when changing a public export, module boundary, schema, route, CLI command, config field, generated artifact, signature, or documented behaviour; conduct a multi-phase program and review a delegated agent's work mid-flight; plan a performance campaign; scaffold a TLA+ model before implementing, and trace-check it against the real system afterward. Distinct from the `review` skill, which reviews a finished branch or PR against coding standards and the originating spec — this one oversees a program you are conducting.
-commands:
-  - template: "scip-query plan-context <target>"
-    when: "Anchor the current flow, consumers, reuse options, and change risks."
-  - template: "scip-query refs <symbol>"
-    when: "Complete or narrow the direct consumer set for a planned symbol change."
-  - template: "scip-query affected <symbol>"
-    when: "Measure transitive impact when the change is not consumer-local."
+description: Write a concise, code-grounded implementation plan for a non-trivial feature, fix, refactor, migration, or retirement. Use scip-query as the primary repository exploration surface and cite exact owners, relationships, behavior, and consumers.
+metadata:
+  commands:
+    - template: 'scip-query search <text>'
+      when: 'Locate exact repository text, a runtime key, or a compiler symbol; use `scip-query search -- <text>` when the literal starts with a dash.'
+    - template: 'scip-query outline <file>'
+      when: 'Locate compiler-owned constructs in a known file.'
+    - template: 'scip-query entrypoints <text>'
+      when: 'Locate an external callable root when its entry surface is known.'
+    - template: 'scip-query evidence --symbol <symbol> --edge <family> --direction <direction> --depth <n> --max-edges <n>'
+      when: 'Project explicitly selected typed relationships from one exact root.'
+    - template: 'scip-query inspect --at <file:line> --view behavior'
+      when: 'Read connected behavior for a named implementation gap.'
+    - template: 'scip-query code <selector>'
+      when: 'Read exact source only when syntax itself can change the decision.'
+    - template: 'scip-query diff-impact'
+      when: 'Map changed symbols and downstream consumers after an edit.'
+    - template: 'scip-query architecture'
+      when: 'Validate declared structural boundaries.'
+    - template: 'scip-query health --full'
+      when: 'Run configured cleanup and quality detectors.'
 ---
 
-# scip-plan
+# SCIP Plan
 
-<!-- BEGIN GENERATED SKILL COMMANDS -->
-## Commands for this skill
-
-| Command | Purpose | Returns | Coverage | When |
-| --- | --- | --- | --- | --- |
-| `scip-query plan-context <target>` | Pre-edit planning context for a symbol, file, or module | definitions and references; callers and callees; dataflow producers and consumers; backward and forward slices; affected symbols; change-surface risk; dependencies and reverse dependencies; module files and exports; external surface use; complexity; churn; co-change partners; active suppressions | `bounded` | Anchor the current flow, consumers, reuse options, and change risks. |
-| `scip-query refs <symbol>` | Find all files referencing a symbol | referencing file paths; reference line numbers grouped by file | `bounded` | Complete or narrow the direct consumer set for a planned symbol change. |
-| `scip-query affected <symbol>` | Transitive closure of symbols that could break if this symbol changes | affected symbol identities, files, and traversal depths | `bounded` | Measure transitive impact when the change is not consumer-local. |
+Write a plan that another coding agent can execute without rediscovering the relevant system.
 
-Use this shortlist first. Open [`../_shared/SKILL.md`](../_shared/SKILL.md) only when it is insufficient.
+<!-- BEGIN GENERATED SKILL COMMANDS -->
+## Command and question manual
+
+| Command syntax | Question it answers |
+| --- | --- |
+| `scip-query search <text>` | Locate exact repository text, a runtime key, or a compiler symbol; use \`scip-query search -- <text>\` when the literal starts with a dash. |
+| `scip-query outline <file>` | Locate compiler-owned constructs in a known file. |
+| `scip-query entrypoints <text>` | Locate an external callable root when its entry surface is known. |
+| `scip-query evidence --symbol <symbol> --edge <family> --direction <direction> --depth <n> --max-edges <n>` | Project explicitly selected typed relationships from one exact root. |
+| `scip-query inspect --at <file:line> --view behavior` | Read connected behavior for a named implementation gap. |
+| `scip-query code <selector>` | Read exact source only when syntax itself can change the decision. |
+| `scip-query diff-impact` | Map changed symbols and downstream consumers after an edit. |
+| `scip-query architecture` | Validate declared structural boundaries. |
+| `scip-query health --full` | Run configured cleanup and quality detectors. |
+
+These commands are controls, not a checklist. Use every capability needed by the task, but make each query answer a distinct question. There is no required sequence or query limit. Run a command's `--help` when you need a flag not shown in its template.
 <!-- END GENERATED SKILL COMMANDS -->
 
-## Purpose
+<!-- BEGIN GENERATED EXPLORATION MANUAL -->
+### Choose a relationship deliberately
 
-Plan and conduct work: a single non-trivial change, public-surface impact, a multi-phase program carried end to end with verification at each handoff (including reviewing a delegated agent's work in flight), a benchmark-driven optimization campaign, and TLA+ modelling both before implementation and as post-implementation trace-conformance.
+| Question | Evidence family | Direction |
+|---|---|---|
+| Who can call or reach this? | `execution` | `incoming` |
+| What can this call or reach? | `execution` | `outgoing` |
+| Where can this value come from? | `dataflow` | `incoming` |
+| Where can this value go? | `dataflow` | `outgoing` |
+| Which producer and consumer rendezvous? | `runtime` | `both` |
+| What resource is observed or changed? | `state` | `both` |
+| What occurs before or after this? | `temporal` | `both` |
+| What interface constrains this? | `contract` | `both` |
+| Are these observations the same entity? | `identity` | `both` |
+| What contains or owns this? | `ownership` | `both` |
+| What does this statically rely on? | `dependencies` | `outgoing` |
 
-Shared mechanics (lookup tips, command families, postchecks, subagent-briefing text, general command catalogue) live in `../_shared/SKILL.md` — load it only when this skill's own shortlist is insufficient.
+Use exact evidence as an observed fact only within its coverage. Derived evidence is deterministically computed; candidate evidence is a lead; mixed evidence must retain its constituent strengths; unknown evidence cannot support a stronger claim. Missing output is not evidence of absence.
 
-## Pick the mode first
+The controls above are complete for ordinary exploration. Run `scip-query capabilities --matrix` only when a named claim depends on uncertain provider support; do not run it for routine orientation.
+<!-- END GENERATED EXPLORATION MANUAL -->
 
-| Situation | Do this |
-|---|---|
-| One non-trivial change, refactor, migration, or bug fix | Ordinary-mode scenario below |
-| The change touches a security boundary, money, a destructive/irreversible op, a persistent-data migration, shared-state concurrency, a broad public API, or an unrollback-able rollout — or the user asks for the rigorous version | `references/high-assurance.md` |
-| You're about to edit a public export, route, schema, CLI command, config field, generated artifact, or documented behavior, and need to know what breaks | `references/api-impact.md` |
-| You're running a multi-phase program: writing an executable plan, delegating steps, reviewing a subagent's work mid-flight, or carrying a change end to end | `references/conductor.md` |
-| You need something faster and must prove the speedup with measurements | `references/hyper-optimization.md` |
-| You need a TLA+ model of a risky protocol, before or after implementation | `references/tla-model.md` |
+scip-query is a repository exploration surface: an indexed code reader that joins exact current text to compiler-owned identities and typed relationships. Use it as the primary exploration surface for tracked repository text. Treat its commands as controls, not a checklist. Use every capability needed by the change, but make each query answer a distinct repository question. There is no mandatory sequence, required anchor phase, or query-count limit.
 
-Picking the mode matters: running the high-assurance certificate on routine work is how planning becomes a tax people route around. When genuinely unsure whether a change needs a heavier mode, ask rather than defaulting up.
+Before planning, understand the relevant initiating surfaces, behavior owners, decisions, data transformations, effects, consumers, existing reuse opportunities, and structural constraints. Use one discriminating locator and reuse its results as graph roots; do not repeat generic synonym searches after usable candidates exist. When several implementations match, compare their entry surfaces, incoming execution, ownership, callers, or runtime connections before selecting one. Locator results are graph roots, not relevance rankings. Read coverage and recovery before making complete-set or absence claims. Use native tools only for edits, checks, binary content, or a specific unsupported gap reported by scip-query.
 
-## Scenario: plan a single non-trivial change (ordinary mode, the default)
+Do not write a plan for one obvious local edit. Write one when correctness depends on several owners or files, downstream consumers, a migration or retirement, reuse of existing behavior, architecture rules, or several coherent implementation slices. Put it in `docs/plans/YYYY-MM-DD-<name>.md` only when it must survive a context reset.
 
-Apply `_shared`'s freshness gate once before citing the first graph fact; let an active watcher handle refreshes and use manual reindex only as the documented fallback. Then run `scip-query plan-context <target>` — the single anchoring call for planning. Its composite return already includes definitions, references, callers, callees, dataflow producers/consumers, forward and backward slices, affected symbols, change-surface risk, dependencies and reverse dependencies, module exports, external surface use, complexity, churn, co-change partners, and active suppressions, so the job is to interpret this composite rather than rebuild a proof system on top of it.
+## Plan shape
 
-Reach for a second command only when a section `plan-context` returned came back bounded (not complete) or the target wasn't indexed: `scip-query refs <symbol>` to enumerate consumers in full, `scip-query affected <symbol>` for the transitive blast radius when the change isn't consumer-local, `scip-query code <symbol>` to read the source behind a behavior claim before writing it into the plan.
+State the observable outcome in one or two sentences. Explain the current behavior with exact symbol and file/line references. Then use this table:
 
-Write the plan to `docs/plans/YYYY-MM-DD-<short-name>.md` with these sections:
-
-- **Goal** — what the user is trying to accomplish, and what done looks like for them.
-- **Current Flow** — the affected path from entry point to observable effect, in prose, with evidence behind each claim; if current behavior can't be described end to end, the change isn't ready to make.
-- **Affected Consumers** — who calls/imports/reads the changed code and what breaks if the contract shifts; state explicitly whether the list is complete or bounded — a capped list presented as complete is worse than one flagged as bounded.
-- **Reuse Decision** — for every new helper/wrapper/type/parameter/flag/component/hook/module, name what it could have extended instead and why extension loses. New parallel code with no reuse decision is the single most common defect this skill exists to prevent.
-- **Slices** — ordered implementation steps, each naming its files/symbols, the behavior change, and the validation (a test, command, or specific manual check) that proves it. A slice with no validation is a wish.
-- **Risks and Unknowns** — what could go wrong, what couldn't be established, and any rollout constraint; keep unknowns explicit rather than rounding them to assumptions.
-
-The plan is done only when: the entry-to-effect path is described and evidenced, every affected consumer is assigned to a slice or explicitly out of scope, every new unit has a reuse decision, every slice has validation, and unknowns are written down rather than resolved by guessing. Then implement in the smallest coherent slice and run `scip-verify` when the change lands.
-
-## Owned command quick-reference
+| Step | Code reference | Change | Preserve or retire | Verify |
+| --- | --- | --- | --- | --- |
+| Coherent implementation slice | Exact symbol and file/line | Concrete edit and why it belongs here | Existing behavior to keep or residue to remove | Check that fails when the outcome is absent |
 
-`bench`, `work-audit` → performance campaigns, see `references/hyper-optimization.md`.
-`tla`, `tla scaffold`, `tla verify`, `tla instrument`, `tla trace-check`, `tla fetch-tools` → model scaffolding and conformance, see `references/tla-model.md`.
+Order the rows so each leaves the repository in a valid state. Include the relevant entry point, behavior owner, downstream consumers, reuse candidates, architecture constraints, migration or cleanup, and validation. Label design choices as choices. Include an open-uncertainty section only when an unresolved repository fact can change the implementation, and name the exact scip-query command that would answer it.
 
-Everything else used above (`plan-context`, `refs`, `affected`, `code`, `surface`, `co-change`, `doc-drift`, `diff-gate`, `health`, `call-graph`, `complexity`, `change-surface`, ...) is general catalogue — see `../_shared/SKILL.md` for the full vocabulary.
+The plan is ready when another agent can implement it without a broad repository rediscovery pass.

package/skills/scip-plan/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "SCIP Plan & Conduct"
-  short_description: "Plan and conduct work with SCIP evidence"
-  default_prompt: "Use $scip-plan to plan this change, assess what it breaks, and conduct it through to verified completion."
+  display_name: 'SCIP Plan'
+  short_description: 'Write concise repository-grounded implementation plans'
+  default_prompt: 'Use $scip-plan to explore the relevant system with scip-query and write a concise implementation plan grounded in exact symbol and file/line references.'

package/skills/scip-query/SKILL.md

@@ -1,82 +1,82 @@
 ---
 name: scip-query
-description: Use FIRST for codebase work that should rest on SCIP evidence. Routes understanding to scip-explore, prospective changes to scip-plan, failures to scip-diagnose, read-only problem finding to scip-audit, confirmed fixes to scip-improve, adoption or repair to scip-setup, and finished diffs to scip-verify.
+description: Use FIRST for codebase work when compiler-resolved identity, runtime boundaries, callers, dependencies, consumers, architecture, change impact, or cleanup relationships can affect the answer. It exposes exact referents, explicit typed-graph projections, and source evidence; it does not infer task relevance.
+metadata:
+  commands:
+    - template: 'scip-query search <text>'
+      when: 'Locate exact repository text, a runtime key, or a compiler symbol; use `scip-query search -- <text>` when the literal starts with a dash.'
+    - template: 'scip-query outline <file>'
+      when: 'Locate compiler-owned constructs in a known file.'
+    - template: 'scip-query entrypoints <text>'
+      when: 'Locate an external callable root when its entry surface is known.'
+    - template: 'scip-query evidence --symbol <symbol> --edge <family> --direction <direction> --depth <n> --max-edges <n>'
+      when: 'Project explicitly selected typed relationships from one exact root.'
+    - template: 'scip-query inspect --at <file:line> --view behavior'
+      when: 'Read connected behavior for a named implementation gap.'
+    - template: 'scip-query code <selector>'
+      when: 'Read exact source only when syntax itself can change the decision.'
+    - template: 'scip-query diff-impact'
+      when: 'Map changed symbols and downstream consumers after an edit.'
+    - template: 'scip-query architecture'
+      when: 'Validate declared structural boundaries.'
+    - template: 'scip-query health --full'
+      when: 'Run configured cleanup and quality detectors.'
 ---
 
-# SCIP Query Router
-
-## Purpose
-
-Choose one owning workflow before acting. An owning workflow is the bundled
-skill whose completion criterion matches the request: understanding, planning,
-diagnosis, read-only auditing, implementation, setup, or verification. The
-router does not perform that workflow itself.
-
-Load `../_shared/SKILL.md` only after the owning workflow's shortlist proves
-insufficient. The shared reference contains the complete command vocabulary,
-coverage rules, and evidence contract; loading it before a route is selected
-adds choices without adding direction.
-
-Run commands normally for agent reading: the human renderer preserves
-hierarchy, whitespace, and line numbers without transport metadata. Select
-`--json` only when a program will parse the response; add `--result-only` when
-that program needs only the command result rather than the stable public
-envelope. Do not select `--compact` or `--output-page-size` for readability.
-Follow an emitted continuation command only when the command itself says the
-output is incomplete. The final transport-complete footer means every rendered
-character was retrieved; inspect command coverage separately before claiming
-the logical result is exhaustive.
-
-## Routes
-
-| The request starts from… | Owning skill | Completion criterion |
-| --- | --- | --- |
-| Existing code that must be understood, traced, or diagrammed | `scip-explore` | Entry points, flow, dependencies, consumers, and remaining uncertainty are evidenced. |
-| A proposed feature, refactor, migration, API change, performance campaign, TLA+ model, or multi-phase program | `scip-plan` | Current flow, affected consumers, reuse decisions, ordered slices, validation, and risks are explicit. |
-| A failure, regression, recurring bug family, raw issue, or parser/AST reachability question | `scip-diagnose` | The observed failure is connected to a cause, rivals are rejected, and the smallest fix packet is defined. |
-| A question about whether problems exist, without permission to edit | `scip-audit` | The scoped items are classified and ranked with evidence; no code or docs are changed. |
-| Confirmed cleanup, drift, maintainability, frontend, directory, twin, or documentation findings that should be fixed | `scip-improve` | One coherent finding slice is changed and passes its routed postchecks. |
-| First adoption, broken setup, missing capabilities, skill installation, hooks, CI, or uninstall | `scip-setup` | The workspace is ready, or every unavailable capability has an explicit blocker. |
-| A finished diff that must be challenged before commit or release | `scip-verify` | Workspace, impact, applicable postchecks, gate findings, and refutation attempts are all accounted for. |
-
-## Disambiguation
-
-- Existing behavior with no symptom routes to `scip-explore`; a contradiction
-  or failure routes to `scip-diagnose`.
-- Finding and classifying problems without edits routes to `scip-audit`;
-  changing already-confirmed findings routes to `scip-improve`.
-- Prospective work routes to `scip-plan`; a concrete finished diff routes to
-  `scip-verify`.
-- Setup wins whenever the index or a required capability is missing, stale,
-  invalid, or not yet installed.
-- A request may cross workflows in sequence. Keep one owner at a time:
-  diagnose before planning a fix, audit before improving, plan before a
-  non-trivial implementation, and verify after every implemented slice.
-
-## Default non-trivial change loop
-
-1. Invoke `scip-plan`, anchored by
-   `scip-query plan-context <target>`.
-2. Implement the smallest coherent planned slice.
-3. Invoke `scip-verify`; do not declare completion until it passes or every
-   remaining finding has a specific evidence-backed disposition.
-
-Routing is complete only when exactly one owner is selected for the current
-phase, or the request is small enough that no compiler-resolved relationship
-claim is needed.
-
-<!-- BEGIN GENERATED ROUTER COMMAND PREVIEW -->
-## Command Preview
-
-Top commands per routed skill, generated from each skill's own `commands:` frontmatter.
-
-| Skill | Top commands |
+# scip-query
+
+<!-- BEGIN GENERATED SKILL COMMANDS -->
+## Command and question manual
+
+| Command syntax | Question it answers |
 | --- | --- |
-| `scip-audit` | `scip-query health`, `scip-query decorative-checkers --full`, `scip-query doc-drift --full` |
-| `scip-diagnose` | `scip-query files <feature-or-error-term>`, `scip-query trace <candidate-symbol>`, `scip-query call-graph <entry-symbol>` |
-| `scip-explore` | `scip-query system <module-or-scope>`, `scip-query trace <entry-symbol>`, `scip-query affected <symbol>` |
-| `scip-improve` | `scip-query cleanup-plan --verify`, `scip-query cleanup-apply --verified --batch <n> --dry-run`, `scip-query diff-gate` |
-| `scip-plan` | `scip-query plan-context <target>`, `scip-query refs <symbol>`, `scip-query affected <symbol>` |
-| `scip-setup` | `scip-query setup --json`, `scip-query doctor`, `scip-query status --capabilities` |
-| `scip-verify` | `scip-query doctor`, `scip-query diff-impact`, `scip-query diff-gate` |
-<!-- END GENERATED ROUTER COMMAND PREVIEW -->
+| `scip-query search <text>` | Locate exact repository text, a runtime key, or a compiler symbol; use \`scip-query search -- <text>\` when the literal starts with a dash. |
+| `scip-query outline <file>` | Locate compiler-owned constructs in a known file. |
+| `scip-query entrypoints <text>` | Locate an external callable root when its entry surface is known. |
+| `scip-query evidence --symbol <symbol> --edge <family> --direction <direction> --depth <n> --max-edges <n>` | Project explicitly selected typed relationships from one exact root. |
+| `scip-query inspect --at <file:line> --view behavior` | Read connected behavior for a named implementation gap. |
+| `scip-query code <selector>` | Read exact source only when syntax itself can change the decision. |
+| `scip-query diff-impact` | Map changed symbols and downstream consumers after an edit. |
+| `scip-query architecture` | Validate declared structural boundaries. |
+| `scip-query health --full` | Run configured cleanup and quality detectors. |
+
+These commands are controls, not a checklist. Use every capability needed by the task, but make each query answer a distinct question. There is no required sequence or query limit. Run a command's `--help` when you need a flag not shown in its template.
+<!-- END GENERATED SKILL COMMANDS -->
+
+<!-- BEGIN GENERATED EXPLORATION MANUAL -->
+### Choose a relationship deliberately
+
+| Question | Evidence family | Direction |
+|---|---|---|
+| Who can call or reach this? | `execution` | `incoming` |
+| What can this call or reach? | `execution` | `outgoing` |
+| Where can this value come from? | `dataflow` | `incoming` |
+| Where can this value go? | `dataflow` | `outgoing` |
+| Which producer and consumer rendezvous? | `runtime` | `both` |
+| What resource is observed or changed? | `state` | `both` |
+| What occurs before or after this? | `temporal` | `both` |
+| What interface constrains this? | `contract` | `both` |
+| Are these observations the same entity? | `identity` | `both` |
+| What contains or owns this? | `ownership` | `both` |
+| What does this statically rely on? | `dependencies` | `outgoing` |
+
+Use exact evidence as an observed fact only within its coverage. Derived evidence is deterministically computed; candidate evidence is a lead; mixed evidence must retain its constituent strengths; unknown evidence cannot support a stronger claim. Missing output is not evidence of absence.
+
+The controls above are complete for ordinary exploration. Run `scip-query capabilities --matrix` only when a named claim depends on uncertain provider support; do not run it for routine orientation.
+<!-- END GENERATED EXPLORATION MANUAL -->
+
+scip-query is a repository exploration surface: an indexed code reader that joins exact current text to compiler-owned identities and typed relationships. Native text and file tools expose matches and slices; scip-query additionally exposes how code units call, carry data, cross runtime boundaries, observe or change state, occur in order, satisfy contracts, share identity, contain one another, and depend on one another. It performs the control you select; it does not infer task relevance or decide what the user meant.
+
+Use scip-query as the primary exploration surface for tracked repository text. Treat its commands as controls, not a checklist. Use every capability needed by the task, but make each query answer a distinct repository question. There is no mandatory sequence, required anchor phase, or query-count limit. Thoroughness means understanding the relevant system end to end, not exhausting the repository.
+
+Use one discriminating exact `search`, `outline`, or `entrypoints` locator, then reuse every returned symbol or `file:line` as an `evidence` root. Do not repeat generic synonym searches after usable candidates exist. Locator ordering does not establish relevance. When several implementations match the same vocabulary, do not select one by path, naming, apparent recency, or result order. Compare their entry surfaces, incoming execution, ownership, callers, or runtime connections; if the repository does not establish one as authoritative, explain the alternatives and their scopes.
+
+An evidence projection accepts repeated `--symbol`, `--at`, or `--search` roots and repeated `--edge <family>` flags; always choose `--direction incoming|outgoing|both`, `--depth <n>`, and `--max-edges <n>` explicitly. Use `--subtype <subtype>` to narrow a family, `--connecting` when the selected roots themselves must be connected, and `--inventory-only` when counts alone can choose the next bounded projection.
+
+Read each command's request, observed facts, evidence calibration, coverage, and recovery together. Exact observations are facts only within their reported coverage. Derived observations are deterministic computations. Candidate observations require confirmation. Missing or bounded output is not evidence of absence.
+
+An emitted `Continue exactly:` command is a cursor: a next-page read from one immutable rendered result. It is required transport, not optional evidence expansion. Run the emitted command unchanged and repeat until no continuation remains before interpreting that command's complete result. Do not rerun the original query or alter cursor flags. Continuation reads saved output without repository preparation, reindexing, or watcher startup. Printed recovery and expansion commands are different: run those only when their omitted evidence matters.
+
+Prefer human output for agent reading. If a model-facing consumer genuinely needs JSON, add `--json --agent-output`; add `--result-only` only when the common envelope is unnecessary, and drain every emitted cursor before interpreting the result. Never send raw `--json` output through a model-facing terminal or tool. When a program needs the exhaustive machine payload, use `--json --json-output <path>` and inspect that file programmatically instead of injecting its complete contents into model context.
+
+`inspect --view behavior` returns connected behavior for named units; `code` returns exact source. Treat source rendered by either command as already read. Batch independent roots and source gaps when practical. Use native tools only for edits, checks, binary content, or a specific unsupported gap reported by scip-query. After edits, use `diff-impact` when downstream consumers matter, `architecture` for declared boundaries, and `health` for configured quality or cleanup detectors.

package/skills/scip-query/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "SCIP Query Router"
-  short_description: "Route a codebase task to the right SCIP skill"
-  default_prompt: "Use $scip-query first to pick the right SCIP-backed skill for this task before doing anything else."
+  display_name: "SCIP Query"
+  short_description: "Explore code through exact identities and relationships"
+  default_prompt: "Use $scip-query as the primary repository exploration surface. Treat commands as controls rather than a checklist, reuse locator results as graph roots, distinguish competing implementations by their entry surfaces and callers, and use exact identities, relationships, behavior, source, coverage, and recovery to understand the requested system accurately."

package/skills/scip-setup/SKILL.md

@@ -1,110 +1,18 @@
 ---
 name: scip-setup
-description: Use to adopt, onboard, repair, or diagnose scip-query ITSELF in a repo — first index, config, capability and dependency checks, installing or uninstalling agent skills, agent guidance blocks, project hooks, CI wiring. Wins over scip-verify for first-time adoption; calibration comes afterward.
-commands:
-  - template: "scip-query setup --json"
-    when: "Bootstrap or repair the complete repository setup."
-  - template: "scip-query doctor"
-    when: "Diagnose configuration, index, dependency, or capability failures."
-  - template: "scip-query status --capabilities"
-    when: "Confirm freshness and the exact evidence capabilities available."
+description: Install, diagnose, index, watch, repair, or clean up scip-query for a repository. Use for setup, freshness, cache ownership, worktrees, watcher behavior, and operational failures—not ordinary code exploration.
 ---
 
-# scip-setup
+# SCIP Setup
 
-## Purpose
+Use this skill when the exploration surface itself is unavailable, stale, slow, or consuming unexpected disk or CPU. An operational diagnosis identifies the concrete state transition that prevented a checkout-local index from becoming or remaining fresh; it does not infer failure from elapsed time alone.
 
-Make a repository a reliable scip-query workspace: indexed, diagnosed,
-documented for agents, and honest about unavailable capabilities. Covers
-first-time adoption, repair after drift, capability/dependency diagnosis, and
-the lifecycle commands that install, refresh, or remove scip-query's footprint
-(skills, agent guidance, hooks, CI).
+1. Run `scip-query status` to inspect the active checkout, index generation, freshness, watcher, and cache ownership.
+2. Run `scip-query doctor` when status reports an inconsistency or a command fails. Treat each reported repair as a separate action.
+3. Run `scip-query setup` for first-time project installation or an explicitly requested repair. Setup establishes the index, generated agent guidance, skill links, and watcher lifecycle; quality analysis is a separate `scip-query health` operation.
+4. Run `scip-query watch` only when the repository needs a long-lived incremental watcher and setup did not establish one.
+5. Use the exact recovery command printed by status or doctor. Do not delete caches, force a full rebuild, or reinstall globally merely because an index is stale; first identify whether configuration, project membership, toolchain identity, or an ordinary changed file caused the transition.
 
-Load shared mechanics from [`../_shared/SKILL.md`](../_shared/SKILL.md). Use
+Each worktree owns its mutable generation and may reuse an immutable baseline from a related checkout. A full rebuild is justified when configuration, toolchain identity, or project membership invalidates the prior compiler graph. Ordinary edits should use the incremental path. Cache cleanup must retain active checkout generations and remove only records whose owning roots are gone or whose retention window has expired.
 
-<!-- BEGIN GENERATED SKILL COMMANDS -->
-## Commands for this skill
-
-| Command | Purpose | Returns | Coverage | When |
-| --- | --- | --- | --- | --- |
-| `scip-query setup --json` | Bootstrap this project: enable automatic indexing, install agent skills, refresh the index, verify capabilities, and report health | setup step outcomes, files, capabilities, smoke tests, and warnings | `complete` | Bootstrap or repair the complete repository setup. |
-| `scip-query doctor` | Diagnose config, index freshness, dependency readiness, and project capabilities | config, freshness, dependency, and capability diagnostics | `complete` | Diagnose configuration, index, dependency, or capability failures. |
-| `scip-query status --capabilities` | Show index status for this project | freshness, generation, language shards, watcher, and optional capabilities | `complete` | Confirm freshness and the exact evidence capabilities available. |
-
-Use this shortlist first. Open [`../_shared/SKILL.md`](../_shared/SKILL.md) only when it is insufficient.
-<!-- END GENERATED SKILL COMMANDS -->
-this skill's own command shortlist first; open the shared file only when it is
-insufficient.
-
-## Triage: which scenario applies
-
-| Situation | Go to |
-| --- | --- |
-| First time running scip-query in this repo, or repairing a broken setup | [Bootstrap workflow](references/bootstrap-workflow.md) — `setup` |
-| `setup` reported a blocker, or index/capabilities look wrong | [Bootstrap workflow §3](references/bootstrap-workflow.md#3-resolve-blockers) — `doctor`, `status`, `capabilities`, `config-validate` |
-| Confirming TypeScript/Vue or Rust semantic readiness specifically | [Language verification](references/language-verification.md) |
-| Need to (re)install skills, agent guidance, hooks, or CI without a full bootstrap | [Lifecycle commands](references/lifecycle-commands.md) |
-| Removing scip-query's footprint from a repo | [Lifecycle commands § uninstall](references/lifecycle-commands.md#uninstall) |
-| New repo has standing findings that are intentional (naming conventions, snapshot docs, coupled files) | [Per-repo triage](references/per-repo-triage.md) |
-| Setup is done and clean; user wants a cleanup report or autonomous cleanup | Hand off to `scip-audit` (report) or `scip-improve` (autonomous) |
-
-## The core scenario
-
-When a repository is new to scip-query, or its setup is suspect, run:
-
-```bash
-scip-query setup --json
-```
-
-`setup` is the bootstrap orchestrator: it installs/repairs language indexers,
-installs Tree-sitter grammars, installs bundled agent skills and hooks,
-enables demand-started incremental indexing, builds SQLite shards, starts the
-project service, checks semantic readiness, and reports repository/checkout/
-environment/runtime state separately. Prefer this single command over
-hand-running its internals. Full step-by-step handling — including what to do
-when it reports `partial` or `blocked` — is in
-[Bootstrap workflow](references/bootstrap-workflow.md).
-
-Do not manually install AST grammar packages before trying `setup`. If npm's
-script-approval gate blocks a native package, report the pending packages and
-ask the user to approve them — a package must not approve its own install
-scripts.
-
-## Rules (apply across every scenario)
-
-1. Prefer the single `setup` command over hand-running its internals.
-2. Do not run `scip-query setup-ci` unless the user explicitly asks for CI
-   setup.
-3. Treat unavailable capabilities as unproven, not clean. A missing semantic
-   provider is "unsupported," never "clean semantic analysis."
-4. Keep `.scipquery.json` minimal and evidence-backed — add a setting only for
-   an observed repo fact, with a reason.
-5. Let `setup` install detected AST parser packages and supported indexers; do
-   not make users reproduce package-manager commands unless `setup` reports a
-   blocker.
-6. A demand-started service or Rust helper in `stopped` state can still be
-   correctly configured. Availability comes from capabilities; lifecycle state
-   only says whether current work keeps the helper awake.
-
-## Report template
-
-```markdown
-Setup: ready/partial/blocked
-Capabilities:
-- available:
-- unavailable:
-Health:
-- score:
-- dossier:
-Written or changed:
-- files:
-Runtime:
-- automatic indexing:
-- TypeScript project/index sessions:
-- Rust semantic transport/lifecycle:
-Next:
-- cleanup audit/improve, CI setup, or external blocker
-```
-
-Fill this in as the closing report for any bootstrap or repair pass — it is
-the fixed template regardless of which reference scenario you used.
+After a repair, prove the requested outcome directly: status is fresh, an ordinary source edit updates incrementally, simultaneous worktrees remain isolated, deleted worktree caches age out, or repeated cleanup reaches a disk plateau. Do not run `health` as proof of index freshness and do not run exploration commands as a substitute for lifecycle diagnostics.

package/skills/scip-setup/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "SCIP Setup"
-  short_description: "Bootstrap or repair scip-query in a repo"
-  default_prompt: "Use $scip-setup to adopt, repair or diagnose scip-query itself in this repository."
+  display_name: 'SCIP Setup'
+  short_description: 'Set up and diagnose SCIP Query indexing'
+  default_prompt: 'Use $scip-setup to install or diagnose scip-query for this repository.'

package/dist/chunk-26QA6FAI.js

@@ -1,8 +0,0 @@
-import{a as k}from"./chunk-DHEQMPLW.js";import{a as $}from"./chunk-C43RDDP4.js";import{a as O,e as P,s as A}from"./chunk-EKZTZXHZ.js";import{o as R}from"./chunk-UJPRPGCO.js";import{E as S,F as w,G as j,K as T}from"./chunk-WCCFZ7V7.js";import{a as d}from"./chunk-NGEXCJJW.js";import{d as g}from"./chunk-7S5E7KWT.js";import{c as f}from"./chunk-C3KV2II6.js";import{existsSync as b,readdirSync as M}from"fs";import{join as p}from"path";var Q={files:new Set,pathPrefixes:[]},z={reasonsByFile:new Map},x=/^(?:dist|build|lib|out|output|esm|cjs|umd)\//,tt=/\.(?:d\.ts|d\.mts|d\.cts|ts|tsx|mts|cts|js|jsx|mjs|cjs)$/,C=[".ts",".tsx",".mts",".cts",".js",".jsx",".mjs",".cjs"],et=new Set([".git",".next",".turbo","build","coverage","dist","node_modules","out"]),rt=4,nt=g("package-surface",{clearGroups:["whole-project"]}),st=g("package-operational-surface",{clearGroups:["whole-project"]});function it(t){return nt.get(t,()=>ot(t.config.projectRoot))}function y(t,e){let r=it(t);return r.files.has(e)?!0:r.pathPrefixes.some(n=>e.startsWith(n))}function at(t){return st.get(t,()=>ct(t.config.projectRoot))}function ee(t,e){return at(t).reasonsByFile.get(e)??[]}function ot(t){let e=new Set,r=[];for(let{manifest:n,packageRoot:i}of N(t))for(let s of ut(n))V(t,i,s,e,r);return e.size===0&&r.length===0?Q:{files:e,pathPrefixes:r}}function ct(t){let e=new Map;for(let{manifest:r,packageRoot:n}of N(t)){let i=ft(r);for(let a of i)F(t,n,a,"package binary",e);let s=r.scripts;if(!(!s||typeof s!="object")){for(let[a,o]of Object.entries(s))if(typeof o=="string")for(let c of gt(o))F(t,n,c,`package script "${a}"`,e)}}return e.size===0?z:{reasonsByFile:e}}function N(t){let e=[],r=v(t,"");return r&&e.push({manifest:r,packageRoot:""}),L(t,"",e,0),e}function L(t,e,r,n){if(n>=rt)return;let i=p(t,e);if(b(i))for(let s of M(i,{withFileTypes:!0})){if(!s.isDirectory()||et.has(s.name))continue;let a=e?`${e}/${s.name}`:s.name,o=v(t,a);o&&r.push({manifest:o,packageRoot:a}),L(t,a,r,n+1)}}function v(t,e){let r;try{r=S(t,p(e,"package.json"),{maxBytes:8*1024*1024,inputKind:"package manifest"})}catch(n){if(!w(n))throw n;return null}try{let n=JSON.parse(r);return n&&typeof n=="object"?n:null}catch{return null}}function ut(t){let e=[];for(let n of["main","module","types","browser"])typeof t[n]=="string"&&e.push(t[n]);let r=t.bin;if(typeof r=="string")e.push(r);else if(r&&typeof r=="object")for(let n of Object.values(r))typeof n=="string"&&e.push(n);return I(t.exports,e),e}function ft(t){let e=t.bin;return typeof e=="string"?[e]:!e||typeof e!="object"?[]:Object.values(e).filter(r=>typeof r=="string")}function gt(t){let e=[],r=/(?:^|&&|\|\||;)\s*(?:(?:cross-env|env)(?:\s+[A-Za-z_][A-Za-z0-9_]*=\S+)*\s+)?(?:node|bun|tsx|ts-node|vite-node|python3?|deno\s+run)\s+(?:(?:--?[A-Za-z0-9-]+(?:=\S+)?)\s+)*["']?([^"'`\s]+\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs|py))["']?/g;for(let n of t.matchAll(r)){let i=n[1];i&&!i.startsWith("node_modules/")&&!i.startsWith("./node_modules/")&&e.push(i)}return e}function F(t,e,r,n,i){let s=new Set;V(t,e,r,s,[]);for(let a of s){let o=i.get(a)??[];o.includes(n)||o.push(n),i.set(a,o)}}function I(t,e){if(typeof t=="string"){e.push(t);return}if(!(!t||typeof t!="object"))for(let r of Object.values(t))I(r,e)}function V(t,e,r,n,i){let s=r.replace(/\\/g,"/").replace(/^\.\//,"");if(s===""||s.startsWith(".."))return;let a=s.indexOf("*");if(a>=0){let c=s.slice(0,a);for(let l of D(c))l!==""&&i.push(u(e,l));return}let o=s.replace(tt,"");for(let c of D(o)){c===o&&c===s&&n.add(u(e,s));for(let l of C)lt(t,n,e,c+l)}n.add(u(e,s))}function D(t){let e=[t];return x.test(t)&&(e.push(t.replace(x,"src/")),e.push(t.replace(x,""))),e}function lt(t,e,r,n){let i=u(r,n);if(e.add(i),!n.startsWith("src/")||b(p(t,i)))return;let s=C.find(m=>n.endsWith(m));if(!s)return;let a=n.slice(0,-s.length);pt(t,e,r,a,s);let o=a.lastIndexOf("/");if(o<=4)return;let c=a.slice(0,o),l=a.slice(o+1);for(let m of B(t,r,c,`${l}${s}`))e.add(m)}function pt(t,e,r,n,i){let s=u(r,`${n}/index${i}`);b(p(t,s))&&e.add(s)}function B(t,e,r,n){let i=p(t,e,r);if(!b(i))return[];let s=[];for(let a of M(i,{withFileTypes:!0})){let o=`${r}/${a.name}`;a.isDirectory()?s.push(...B(t,e,o,n)):a.isFile()&&a.name===n&&s.push(u(e,o))}return s}function u(t,e){return t?`${t}/${e}`:e}import{existsSync as E,readdirSync as dt}from"fs";import{dirname as St,join as _}from"path";var bt={rootFiles:new Set,sourcePrefixes:[]},ht=new Set([".git",".scipquery","node_modules","target"]),mt=6,Pt=g("rust-library-surface",{clearGroups:["whole-project"]});function W(t,e,r){if(!r.endsWith(".rs")||!Et(xt(t),r))return!1;let n=A(t,r).find(i=>i.symbol===e);return n?_t(T(t,r)[n.startLine]??""):!1}function xt(t){return Pt.get(t,()=>yt(t.config.projectRoot))}function yt(t){let e=new Set,r=new Set;for(let n of kt(t)){let i=S(t,_(n,"Cargo.toml"),{maxBytes:8388608,inputKind:"Cargo manifest"}),s=wt(i),a=u(n,"src/lib.rs"),o=s?u(n,s):!jt(i)&&j(t,a)?a:null;if(!o)continue;e.add(o);let c=St(o).replaceAll("\\","/");r.add(c==="."?"":`${c}/`)}return e.size===0?bt:{rootFiles:e,sourcePrefixes:[...r].sort()}}function Et(t,e){return e.endsWith(".rs")?t.rootFiles.has(e)?!0:Tt(e)?!1:t.sourcePrefixes.some(r=>e.startsWith(r)):!1}function _t(t){return/^\s*pub\s+(?!\()/.test(t)}function kt(t){if(!E(t))return[];let e=[];return X(t,"",e,0),e}function X(t,e,r,n){let i=_(t,e);if(E(i)&&(E(_(i,"Cargo.toml"))&&r.push(e),!(n>=mt)))for(let s of dt(i,{withFileTypes:!0})){if(!s.isDirectory()||ht.has(s.name))continue;let a=e?`${e}/${s.name}`:s.name;X(t,a,r,n+1)}}function wt(t){let e=!1;for(let r of t.split(`
-`)){let n=r.replace(/\s+#.*$/,"").trim(),i=/^\[([^\]]+)\]$/.exec(n);if(i){e=i[1]==="lib";continue}if(!e)continue;let s=/^path\s*=\s*["']([^"']+)["']/.exec(n)?.[1];if(s)return s.replaceAll("\\","/").replace(/^\.\//,"")}return null}function jt(t){let e=!1;for(let r of t.split(`
-`)){let n=r.replace(/\s+#.*$/,"").trim(),i=/^\[([^\]]+)\]$/.exec(n);if(i){e=i[1]==="package";continue}if(e&&/^autolib\s*=\s*false\b/.test(n))return!0}return!1}function Tt(t){return/(?:^|\/)src\/main\.rs$/.test(t)||/(?:^|\/)src\/bin\//.test(t)||/(?:^|\/)(?:examples|tests|benches)\//.test(t)}function h(t){let e=f(t);return Ht(e)?"test":Kt(e)?"worker":Yt(e)?"entry":Zt(e)?"barrel":"source"}function Rt(t){return h(t)==="barrel"}function U(t){return $t.get(t,()=>{let r=d(t,{includeIgnored:!1}).filter(a=>{let o=h(a);return o==="entry"||o==="worker"});if(r.length===0)return new Set;let n=$(t),i=new Set,s=new Set;for(;r.length>0;){let a=r.shift();if(!i.has(a)){i.add(a),h(a)==="barrel"&&s.add(a);for(let o of n.get(a)??[])i.has(o)||r.push(o)}}return s})}var $t=g("live-barrels",{clearGroups:["whole-project"]});function Ot(t,e){return U(t).has(f(e))}function ye(t){let e=U(t);return d(t,{includeIgnored:!1}).filter(r=>Rt(r)&&!e.has(r)&&!At(t,r))}function At(t,e){let r=f(e),n=O(t).forFile(r,{facts:!0}).facts?.callables;return n&&n.length>0?!0:(t.get(`SELECT COUNT(*) AS n
-     FROM defn_enclosing_ranges der
-     JOIN documents d ON d.id = der.document_id
-     WHERE d.relative_path = ?
-       AND der.end_line - der.start_line >= 2`,r)?.n??0)>0}function Ee(t,e){let r=f(e),n=h(e);return n==="entry"||n==="worker"||Xt(r)||Ot(t,r)}function _e(t,e,r){let n=f(r);if(y(t,n)||Dt(t,e,n)||W(t,e,n)||Wt(e,n))return!0;let i=t.config.entryRoots;return i?!!(i.files?.some(s=>f(s)===n)||i.pathPrefixes?.some(s=>n.startsWith(f(s)))||i.qualifiedVars?.some(s=>qt(e,s))||i.symbolPatterns?.some(s=>{try{return k(s,"entryRoots.symbolPatterns entry").test(e)}catch{return!1}})):!1}var Ft=g("package-surface-reachability",{clearGroups:["whole-project"]});function Dt(t,e,r){let n=Mt(t).get(r);return n===void 0?!1:n===null||n.has(P(e))}function Mt(t){return Ft.get(t,()=>{let e=new Map,r=[];for(let n of d(t,{includeIgnored:!1}))y(t,n)&&(e.set(n,null),r.push(n));for(;r.length>0;){let n=r.shift(),i=e.get(n);if(i!==void 0)for(let s of R(t,n)){if(!s.sourcePath||t.isIgnored(s.sourcePath))continue;let a=Ct(i,s);a!==void 0&&Nt(e,s.sourcePath,a)&&r.push(s.sourcePath)}}return e})}function Ct(t,e){if(t===null)return e.kind==="named"?new Set(e.names):null;if(e.kind==="star")return new Set(t);if(e.kind==="star-as")return;let r=e.names.filter(n=>t.has(n));return r.length>0?new Set(r):void 0}function Nt(t,e,r){if(!t.has(e))return t.set(e,r),!0;let n=t.get(e);if(n===void 0)return!1;if(n===null||r===null)return n===null?!1:(t.set(e,null),!0);let i=!1;for(let s of r)n.has(s)||(n.add(s),i=!0);return i}var H=new Set(["GET","POST","PUT","PATCH","DELETE","HEAD","OPTIONS"]),Lt=new Set(["default","generateMetadata","generateStaticParams"]),vt=new Set(["default","getStaticProps","getServerSideProps","getStaticPaths","config"]),It=new Set(["default","loader","action","clientLoader","clientAction","headers","links","meta","shouldRevalidate","ErrorBoundary","HydrateFallback"]),Vt=new Set(["load","actions","entries",...H]),Bt=new Set(["default"]);function Wt(t,e){let r=P(t);return r===""?!1:K(e)?H.has(r):Y(e)?Lt.has(r):Z(e)?vt.has(r):q(e)?It.has(r):J(e)?Vt.has(r):Ut(e)?Bt.has(r):!1}function Xt(t){return K(t)||Y(t)||Z(t)||Gt(t)||q(t)||J(t)}function K(t){return/(?:^|\/)app(?:\/[^/]+)*\/route\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(t)}function Y(t){return/(?:^|\/)app(?:\/[^/]+)*\/(?:page|layout|template|loading|error|not-found|global-error|head|default)\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(t)}function Z(t){return/(?:^|\/)pages\/.+\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(t)}function Gt(t){let e="(?:middleware|proxy|instrumentation)\\.(?:ts|js|mts|mjs)";return new RegExp(`^(?:src/)?${e}$`).test(t)||new RegExp(`(?:^|/)src/${e}$`).test(t)||new RegExp(`(?:^|/)(?:apps|services|packages)/[^/]+/(?:src/)?${e}$`).test(t)}function q(t){return/(?:^|\/)app\/routes\/.+\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(t)}function J(t){return/(?:^|\/)src\/routes\/(?:.*\/)?\+(?:page|page\.server|layout|layout\.server|server)\.(?:ts|js)$/.test(t)}function Ut(t){return/(?:^|\/)src\/(?:pages|views|routes)\/.+\.(?:ts|tsx|js|jsx|vue)$/.test(t)}function Ht(t){return!!(/\.(?:test|spec)\.[a-z0-9]+$/i.test(t)||/(?:^|\/)(?:_)?test_[^/]+$/i.test(t)||/(?:^|\/)spec_[^/]+$/i.test(t)||/(?:^|\/)[^/]+_test\.[a-z0-9]+$/i.test(t)||/(?:^|\/)[^/]+_tests\.rs$/i.test(t)||/(?:^|\/)tests\.rs$/i.test(t)||/(?:^|\/)[^/]+_spec\.[a-z0-9]+$/i.test(t)||/(?:^|\/)__tests__\//i.test(t)||/(?:^|\/)test\//i.test(t)||/(?:^|\/)tests\//i.test(t)||/(?:^|\/)__fixtures__\//i.test(t)||/(?:^|\/)__mocks__\//i.test(t)||/(?:^|\/)test-support\//i.test(t)||/(?:^|\/)test-utils\//i.test(t)||/(?:^|\/)testing\//i.test(t))}function Kt(t){return/(?:^|\/)[^/]*worker\.(?:ts|tsx|js|mjs|cjs|rs|py|go)$/.test(t)}function Yt(t){let e=t.split("/"),r=e[e.length-1]??t;return r==="cli.ts"||r==="cli.js"||r==="postinstall.ts"||r==="postinstall.js"||r==="main.ts"||r==="main.js"||r==="main.rs"||r==="main.go"||r==="main.py"||r==="build.rs"||r==="lib.rs"||/\bsrc\/bin\/[^/]+\.rs$/.test(t)||/(?:^|\/)examples\/[^/]+\.rs$/.test(t)||/(?:^|\/)tests\/[^/]+\.rs$/.test(t)||/(?:^|\/)benches\/[^/]+\.rs$/.test(t)?!0:r==="index.ts"||r==="index.js"?/(?:^|\/)(?:apps|services)\/[^/]+\/src\/index\.(?:ts|js)$/.test(t)?!0:e.length<=2:!1}function Zt(t){return t==="index.ts"||t==="index.js"||t.endsWith("/index.ts")||t.endsWith("/index.js")||t.endsWith("/mod.rs")||t.endsWith("/__init__.py")}function qt(t,e){let r=e.lastIndexOf("/");if(r<0)return!1;let n=e.slice(0,r),i=e.slice(r+1);return t.includes(G(n)+"/")&&t.includes(G(i)+".")}function G(t){return/^[A-Za-z0-9_$+-]+$/.test(t)?t:"`"+t.replace(/`/g,"``")+"`"}export{y as a,ee as b,h as c,Rt as d,Ot as e,ye as f,Ee as g,_e as h,Xt as i};
-//# sourceMappingURL=chunk-26QA6FAI.js.map

package/dist/chunk-2KAZEZ6M.js

@@ -1,2 +0,0 @@
-import{closeSync as p,fstatSync as g,openSync as l,readFileSync as B,readSync as y}from"fs";import{createHash as P}from"crypto";var h=8*1024*1024,A=64*1024*1024,F=512*1024*1024,L=256*1024*1024,c=class extends Error{constructor(r,o,i,n,a){let s=i==="too-large"?`is ${n} bytes; the safety limit is ${a} bytes`:i==="not-regular"?"is not a regular file":"changed while it was being read";super(`${r} ${JSON.stringify(o)} ${s}`);this.inputKind=r;this.inputPath=o;this.reason=i;this.observedBytes=n;this.limitBytes=a;this.name="BoundedFileReadError"}inputKind;inputPath;reason;observedBytes;limitBytes;code="SCIP_QUERY_BOUNDED_FILE_READ"};function x(e,t){m(t.maxBytes);let r=String(e),o=l(e,"r");try{let i=g(o);R(i,t,r);let n=B(o),a=g(o);if(a.dev!==i.dev||a.ino!==i.ino||a.size!==i.size||n.byteLength!==i.size)throw new c(t.inputKind,r,"changed-during-read",a.size,t.maxBytes);return n}finally{p(o)}}function b(e,t,r="utf8"){return x(e,t).toString(r)}function T(e,t){return b(e,{maxBytes:h,inputKind:t})}function f(e,t){m(t.maxBytes);let r=[],o=Buffer.allocUnsafe(64*1024),i=0;for(;;){let n=y(e,o,0,o.length,null);if(n===0)break;if(i+=n,!Number.isSafeInteger(i)||i>t.maxBytes)throw new c(t.inputKind,`file descriptor ${e}`,"too-large",i,t.maxBytes);r.push(Buffer.from(o.subarray(0,n)))}return Buffer.concat(r,i)}function v(e,t,r="utf8"){return f(e,t).toString(r)}function S(e,t){let r=l(e,"r");try{return f(r,t)}finally{p(r)}}function k(e,t,r="utf8"){return S(e,t).toString(r)}function C(e,t,r){m(t.maxBytes);let o=String(e),i=l(e,"r");try{let n=g(i);R(n,t,o);let a=Buffer.allocUnsafe(Math.min(1024*1024,Math.max(1,n.size))),s=0;for(;s<n.size;){let d=y(i,a,0,Math.min(a.length,n.size-s),s);if(d===0)break;r(a.subarray(0,d)),s+=d}let u=g(i);if(u.dev!==n.dev||u.ino!==n.ino||u.size!==n.size||s!==n.size)throw new c(t.inputKind,o,"changed-during-read",u.size,t.maxBytes);return s}finally{p(i)}}function E(e,t){let r=P("sha256");return C(e,t,o=>r.update(o)),r.digest("hex")}function R(e,t,r){if(!e.isFile())throw new c(t.inputKind,r,"not-regular",Number(e.size),t.maxBytes);if(e.size>t.maxBytes)throw new c(t.inputKind,r,"too-large",Number(e.size),t.maxBytes)}function m(e){if(!Number.isSafeInteger(e)||e<0)throw new RangeError(`maxBytes must be a non-negative safe integer; received ${e}`)}function D(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}function W(e){return typeof e=="string"&&Number.isFinite(Date.parse(e))}function z(e){return typeof e=="number"&&Number.isSafeInteger(e)&&e>=0}var K=["typescript","javascript","java","scala","kotlin","rust","python","ruby","go","cpp","c","csharp","vb","dart","php","clojure"],Y=["entry-surface","generated-code","compatibility-shim","reflection-or-registration","test-fixture","intentional-twin","historical-coupling-ended","detector-counterexample"];export{D as a,W as b,z as c,K as d,Y as e,h as f,A as g,F as h,L as i,c as j,x as k,b as l,T as m,v as n,k as o,C as p,E as q};
-//# sourceMappingURL=chunk-2KAZEZ6M.js.map

package/dist/chunk-3ORVDL3H.js

@@ -1,2 +0,0 @@
-import{c}from"./chunk-B75HZHUP.js";import{a,b as n}from"./chunk-Z4N3MZYA.js";import{o as t}from"./chunk-7O5IKBTZ.js";import{a as m}from"./chunk-T7YQSHPQ.js";import{d as o,h as r}from"./chunk-EKZTZXHZ.js";function N(s,y,b={}){let l=m(s,y);if(!l)return null;let i=b.semantic!==!1,f=n(s,l,{semantic:i,semanticEvidence:t}).filter(e=>r(e.symbol)).slice(0,50),p=c(a(s,l,{limit:50,additive:!0,callableOnly:!0,semantic:i,semanticEvidence:t}));return{symbol:l.symbol,shortName:o(l.symbol),callers:f.map(e=>({symbol:e.symbol,shortName:o(e.symbol),file:e.file})),callees:p.map(e=>({symbol:e.symbol,shortName:o(e.symbol),file:e.file}))}}export{N as a};
-//# sourceMappingURL=chunk-3ORVDL3H.js.map

package/dist/chunk-46XGSFNI.js

@@ -1,2 +0,0 @@
-import{closeSync as l,fstatSync as f,openSync as h,readFileSync as L,readSync as g}from"fs";import{createHash as A}from"crypto";var y=8*1024*1024,R=64*1024*1024,_=512*1024*1024,b=256*1024*1024,d=class extends Error{constructor(i,a,r,n,o){let s=r==="too-large"?`is ${n} bytes; the safety limit is ${o} bytes`:r==="not-regular"?"is not a regular file":"changed while it was being read";super(`${i} ${JSON.stringify(a)} ${s}`);this.inputKind=i;this.inputPath=a;this.reason=r;this.observedBytes=n;this.limitBytes=o;this.name="BoundedFileReadError"}inputKind;inputPath;reason;observedBytes;limitBytes;code="SCIP_QUERY_BOUNDED_FILE_READ"};function B(t,e){m(e.maxBytes);let i=String(t),a=h(t,"r");try{let r=f(a);T(r,e,i);let n=L(a),o=f(a);if(o.dev!==r.dev||o.ino!==r.ino||o.size!==r.size||n.byteLength!==r.size)throw new d(e.inputKind,i,"changed-during-read",o.size,e.maxBytes);return n}finally{l(a)}}function x(t,e,i="utf8"){return B(t,e).toString(i)}function E(t,e){return x(t,{maxBytes:y,inputKind:e})}function p(t,e){m(e.maxBytes);let i=[],a=Buffer.allocUnsafe(64*1024),r=0;for(;;){let n=g(t,a,0,a.length,null);if(n===0)break;if(r+=n,!Number.isSafeInteger(r)||r>e.maxBytes)throw new d(e.inputKind,`file descriptor ${t}`,"too-large",r,e.maxBytes);i.push(Buffer.from(a.subarray(0,n)))}return Buffer.concat(i,r)}function F(t,e){let i=h(t,"r");try{return p(i,e)}finally{l(i)}}function P(t,e,i="utf8"){return F(t,e).toString(i)}function S(t,e,i){m(e.maxBytes);let a=String(t),r=h(t,"r");try{let n=f(r);T(n,e,a);let o=Buffer.allocUnsafe(Math.min(1024*1024,Math.max(1,n.size))),s=0;for(;s<n.size;){let c=g(r,o,0,Math.min(o.length,n.size-s),s);if(c===0)break;i(o.subarray(0,c)),s+=c}let u=f(r);if(u.dev!==n.dev||u.ino!==n.ino||u.size!==n.size||s!==n.size)throw new d(e.inputKind,a,"changed-during-read",u.size,e.maxBytes);return s}finally{l(r)}}function I(t,e){let i=A("sha256");return S(t,e,a=>i.update(a)),i.digest("hex")}function T(t,e,i){if(!t.isFile())throw new d(e.inputKind,i,"not-regular",Number(t.size),e.maxBytes);if(t.size>e.maxBytes)throw new d(e.inputKind,i,"too-large",Number(t.size),e.maxBytes)}function m(t){if(!Number.isSafeInteger(t)||t<0)throw new RangeError(`maxBytes must be a non-negative safe integer; received ${t}`)}export{y as a,R as b,_ as c,b as d,d as e,B as f,x as g,E as h,P as i,S as j,I as k};
-//# sourceMappingURL=chunk-46XGSFNI.js.map

package/dist/chunk-4MAK2HOY.js

@@ -1,6 +0,0 @@
-import{a as d}from"./chunk-S7OYBOCK.js";import{a as f}from"./chunk-T7YQSHPQ.js";import{d as m}from"./chunk-EKZTZXHZ.js";import{E as u,F as g}from"./chunk-WCCFZ7V7.js";import{extname as y}from"path";function M(t,e,r={}){let{context:n=0}=r,a=R(e);if(a)return x(t,a.filePath,a.startLine,a.endLine,n);let i=f(t,e);return i?L(t,i,n):null}function R(t){let e=t.match(/^(.+\.\w+):(\d+)-(\d+)$/);if(!e)return null;let r=Number(e[2]),n=Number(e[3]);if(!Number.isSafeInteger(r)||r<1)throw new RangeError(`Source range start line must be a positive integer, got "${e[2]}".`);if(!Number.isSafeInteger(n)||n<r)throw new RangeError(`Source range end line must be an integer at or after ${r}, got "${e[3]}".`);return{filePath:e[1],startLine:r,endLine:n}}function L(t,e,r){let n=t.get("SELECT language FROM documents WHERE relative_path = ?",e.relativePath),a;try{a=u(t.config.projectRoot,e.relativePath,{inputKind:"indexed source file"})}catch(l){if(!g(l))throw l;return null}let i=a.split(`
-`),s=Math.max(0,e.startLine-r),o=Math.min(i.length-1,e.endLine+r),c=i.slice(s,o+1).join(`
-`);return{symbol:e.symbol,shortName:m(e.symbol),relativePath:e.relativePath,startLine:s,endLine:o,language:n?.language??b(e.relativePath),source:c}}function x(t,e,r,n,a){let i=d(t,e);if(!i)return null;let s=t.get("SELECT relative_path, language FROM documents WHERE relative_path = ?",i);if(!s)return null;let o;try{o=u(t.config.projectRoot,s.relative_path,{inputKind:"indexed source file"})}catch(h){if(!g(h))throw h;return null}let c=o.split(`
-`),l=Math.max(0,r-1-a),p=Math.min(c.length-1,n-1+a),v=c.slice(l,p+1).join(`
-`);return{symbol:`${s.relative_path}:${r}-${n}`,shortName:`${s.relative_path}:${r}-${n}`,relativePath:s.relative_path,startLine:l,endLine:p,language:s.language??b(s.relative_path),source:v}}function b(t){switch(y(t).toLowerCase()){case".ts":case".tsx":case".mts":case".cts":return"typescript";case".js":case".jsx":case".mjs":case".cjs":return"javascript";case".py":case".pyi":return"python";case".rs":return"rust";case".go":return"go";case".java":return"java";case".kt":case".kts":return"kotlin";case".scala":return"scala";case".rb":return"ruby";case".php":return"php";case".cs":return"csharp";case".vb":return"vb";case".dart":return"dart";case".c":case".h":return"c";case".cc":case".cpp":case".cxx":case".hpp":case".hh":case".hxx":return"cpp";case".vue":return"vue";default:return null}}export{M as a};
-//# sourceMappingURL=chunk-4MAK2HOY.js.map

package/dist/chunk-4TURLRL5.js

@@ -1,16 +0,0 @@
-import{c as p}from"./chunk-UJCOIXDY.js";import{a as y}from"./chunk-T7YQSHPQ.js";import{d}from"./chunk-EKZTZXHZ.js";import{b as h}from"./chunk-UJPRPGCO.js";import{A as l}from"./chunk-GH74ASD6.js";import{E as u,F as f}from"./chunk-WCCFZ7V7.js";function T(t,e,s={}){let n=y(t,e);if(!n)return null;let a=new p(t),o=P(t,n),r=n.endLine-n.startLine+1,m=a.calleeMap([n],{additive:!0,semantic:s.semantic}).get(n.symbolId)??[],c=new Set(m.map(B=>B.symbol));return{symbol:n.symbol,shortName:d(n.symbol),relativePath:n.relativePath,startLine:n.startLine,endLine:n.endLine,loc:r,branches:o.branches,estimateBasis:o.estimateBasis,cyclomaticEstimate:o.branches+1,calleeCount:c.size,fanIn:L(t,n.symbolId),fanOut:w(m,n.relativePath)}}function P(t,e){let s=l(t,e.relativePath);if(s){let n=x(s.rootNode,e.startLine,e.endLine);if(n)return{branches:v(n),estimateBasis:"ast"}}return{branches:E(S(t,e.relativePath,e.startLine,e.endLine),g(t,e.relativePath)),estimateBasis:"regex-fallback"}}function j(t,e){let s=new Map,n=new Map;for(let a of e){let o=n.get(a.relativePath)??[];o.push(a),n.set(a.relativePath,o)}for(let[a,o]of n){let r=l(t,a),i=r===null?[]:o.filter(c=>r.rootNode.startPosition.row<=c.startLine&&r.rootNode.endPosition.row>=c.endLine),m=new Set(i.map(c=>c.symbolId));if(r&&i.length>0){for(let c of i)s.set(c.symbolId,{branches:0,estimateBasis:"ast"});M(r.rootNode,i,s)}for(let c of o)m.has(c.symbolId)||s.set(c.symbolId,N(t,c))}return s}function N(t,e){return{branches:E(S(t,e.relativePath,e.startLine,e.endLine),g(t,e.relativePath)),estimateBasis:"regex-fallback"}}function g(t,e){return t.get("SELECT language FROM documents WHERE relative_path = ?",e)?.language??"unknown"}function S(t,e,s,n){try{return u(t.config.projectRoot,e,{inputKind:"indexed source file"}).split(`
-`).slice(s,n+1).join(`
-`)}catch(a){if(!f(a))throw a;return""}}function L(t,e){return t.get(`SELECT COUNT(DISTINCT c.document_id) AS c
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN (
-      SELECT m2.symbol_id, c2.document_id
-      FROM mentions m2
-      JOIN chunks c2 ON m2.chunk_id = c2.id
-      WHERE m2.role = 1
-      GROUP BY m2.symbol_id
-    ) sym_def ON sym_def.symbol_id = m.symbol_id
-    WHERE m.symbol_id = ?
-      AND m.role != 1
-      AND sym_def.document_id != c.document_id`,e)?.c??0}function w(t,e){return new Set(t.filter(s=>s.file!==e).map(s=>s.symbol)).size}function v(t){let e=0;return b(t,s=>{e+=_(s)}),e}function M(t,e,s){let n=[...e].sort((a,o)=>a.startLine-o.startLine||o.endLine-a.endLine);b(t,a=>{let o=_(a);if(o===0)return;let r=a.startPosition.row,i=a.endPosition.row;for(let m of n){if(m.startLine>r)break;if(m.endLine<i)continue;let c=s.get(m.symbolId);c&&(c.branches+=o)}})}function b(t,e){e(t);for(let s of t.namedChildren)b(s,e)}function x(t,e,s){if(t.startPosition.row>e||t.endPosition.row<s)return null;for(let n of t.namedChildren){let a=x(n,e,s);if(a)return a}return t}var C=new Set(["if_statement","conditional_expression","ternary_expression","for_statement","for_in_statement","for_of_statement","while_statement","do_statement","switch_case","case_statement","catch_clause","except_clause","elif_clause","match_arm"]);function _(t){return C.has(t.type)?1:t.type==="binary_expression"&&t.parent?.type!=="binary_expression"&&(t.text.includes("&&")||t.text.includes("||"))?D(t.text):0}function D(t){return(t.match(/&&|\|\|/g)??[]).length}function E(t,e){let s=h(t),n=0,a=[/\bif\b/g,/\belse\s+if\b/g,/\belse\b/g,/\bfor\b/g,/\bwhile\b/g,/\bswitch\b/g,/\bcase\b/g,/\bcatch\b/g,/\?\s*[^?]/g,/&&/g,/\|\|/g];for(let o of a){let r=s.match(o);r&&(n+=r.length)}if(e==="python"){let o=[/\belif\b/g,/\bexcept\b/g,/\bfinally\b/g];for(let r of o){let i=s.match(r);i&&(n+=i.length)}}else if(e==="rust"){let o=[/\bmatch\b/g,/=>/g,/\bloop\b/g];for(let r of o){let i=s.match(r);i&&(n+=i.length)}}else if(e==="ruby"){let o=[/\belsif\b/g,/\bunless\b/g,/\brescue\b/g,/\bwhen\b/g];for(let r of o){let i=s.match(r);i&&(n+=i.length)}}else if(e==="go"){let o=[/\bselect\b/g,/\bdefer\b/g];for(let r of o){let i=s.match(r);i&&(n+=i.length)}}return n}export{T as a,P as b,j as c,v as d};
-//# sourceMappingURL=chunk-4TURLRL5.js.map