scip-query 0.19.5 → 0.19.8

package/skills/scip-debug/SKILL.md

@@ -1,130 +0,0 @@
----
-name: scip-debug
-description: Debug why something is broken, does not work, crashes, fails a test, returns wrong data, or regressed. Uses scip-query to trace the runtime path and data flow, separate rival causes, and make the smallest verified fix.
-commands:
-  - template: 'scip-query files <feature-or-error-term>'
-    when: 'Find the entry point from a feature name or error term.'
-  - template: 'scip-query trace <candidate-symbol>'
-    when: 'Find the entry point: definition plus every reference.'
-  - template: 'scip-query call-graph <entry-symbol>'
-    when: 'Follow execution: callers and callees along the failing path.'
-  - template: 'scip-query dataflow <symbol-or-variable>'
-    when: 'Follow data: producers, consumers, and usage sites.'
-  - template: 'scip-query similar <suspect-symbol> --json --full'
-    when: 'Compare nearby implementations for missing guards or handling.'
-  - template: 'scip-query change-surface <suspect-file> --json --full'
-    when: 'Bound the fix: exports, consumers, and blast-radius risk.'
----
-
-# scip-debug
-
-Use this skill to move from a reported failure to a minimal verified fix. A bug is a mismatch between expected behavior and observed behavior in a concrete execution path. A root cause is the earliest code fact in that path that explains the mismatch.
-
-Load shared mechanics from [`../_shared/SKILL.md`](../_shared/SKILL.md).
-
-<!-- BEGIN GENERATED SKILL COMMANDS -->
-## Commands for this skill
-
-| Command | Purpose | Returns | Coverage | When |
-| --- | --- | --- | --- | --- |
-| `scip-query files <feature-or-error-term>` | Find files matching a pattern | matching file paths | `complete` | Find the entry point from a feature name or error term. |
-| `scip-query trace <candidate-symbol>` | Trace a symbol: definition + all references | definition sites with source and signature; referencing files with line numbers | `bounded` | Find the entry point: definition plus every reference. |
-| `scip-query call-graph <entry-symbol>` | Show incoming callers and outgoing callees for a symbol | caller and callee symbol identities with files | `bounded` | Follow execution: callers and callees along the failing path. |
-| `scip-query dataflow <symbol-or-variable>` | Reference-level dataflow: definition sites, usage sites, producers, consumers | definition sites, usage sites, producer symbols, and consumer symbols | `bounded` | Follow data: producers, consumers, and usage sites. |
-| `scip-query similar <suspect-symbol> --json --full` | Find heuristic function similarity candidates from callee fingerprints | symbol pairs, similarity scores, and shared evidence | `bounded` | Compare nearby implementations for missing guards or handling. |
-| `scip-query change-surface <suspect-file> --json --full` | Pre-change briefing: exports, consumers, and blast-radius risk | defined symbols, external consumer counts, and risk levels | `bounded` | Bound the fix: exports, consumers, and blast-radius risk. |
-
-Use this shortlist first. Open [`../_shared/SKILL.md`](../_shared/SKILL.md) only when it is insufficient.
-<!-- END GENERATED SKILL COMMANDS -->
-
-## Rules
-
-1. Reproduce or restate the failure before editing.
-2. Use scip-query to find entry points, call paths, data flow, and blast radius.
-3. Prefer one narrow fix over broad cleanup.
-4. Verify with the narrowest repo test or smoke command, then invoke `scip-verify`.
-5. A root-cause claim whose fix crosses a file boundary requires a rival: state the next-most-plausible explanation for the same symptom and run the observation that separates them. A root cause with no rival considered is a guess with confidence.
-
-## Workflow
-
-### 1. Pin the failure
-
-Record observed behavior, expected behavior, reproducing command/route/UI action/test/job/file, error text or wrong output, and regression window if known.
-
-If no reproduction is provided, build the smallest runnable reproduction from existing tests, scripts, CLI, or app entry points.
-
-This step is complete only when the mismatch is concrete enough to test or the missing external fact is named.
-
-### 2. Find the entry point
-
-```bash
-scip-query files <feature-or-error-term>
-scip-query outline <candidate-file>
-scip-query trace <candidate-symbol>
-scip-query code <candidate-symbol>
-```
-
-Use `kind-counts` or `by-kind` when the codebase is unfamiliar.
-
-This step is complete only when the failing path has a plausible entry point with source evidence.
-
-### 3. Follow execution and data
-
-```bash
-scip-query call-graph <entry-symbol>
-scip-query code <callee-symbol>
-scip-query refs <state-or-api-symbol>
-scip-query fan-in <suspect-symbol>
-scip-query fan-out <suspect-file>
-scip-query dataflow <symbol-or-variable>
-scip-query slice <symbol-or-variable>
-scip-query slice <symbol-or-variable> --forward
-```
-
-Stop expanding when the first code fact that can cause the symptom is found.
-
-When a candidate cause emerges, state it as a hypothesis alongside one rival — the next-most-plausible explanation for the same symptom. Name the observation that distinguishes them (a log line, a probe, a narrower test) and execute it. Choose the discriminator that is cheapest to run, not the one most likely to confirm.
-
-This step is complete only when the path explains the symptom or the missing evidence is explicit.
-
-### 4. Compare nearby implementations
-
-```bash
-scip-query similar <suspect-symbol> --json --full
-scip-query similar <suspect-symbol> <similar-symbol> --plan
-scip-query similar-files <suspect-file> --json --full
-```
-
-Use comparisons to find missing guards, conversions, lifecycle steps, or error handling. Preserve essential differences.
-
-This step is complete only when comparisons either support the fix or are rejected with a reason.
-
-### 5. Bound and fix
-
-```bash
-scip-query change-surface <suspect-file> --json --full
-scip-query affected <suspect-symbol> --json
-```
-
-Make the smallest code change that fixes the root cause.
-
-This step is complete only when the changed symbol/file is justified by blast-radius evidence.
-
-### 6. Verify
-
-Run the reproduction, narrow test or smoke command, and invoke `scip-verify`.
-
-## Report
-
-```markdown
-Bug:
-Entry point:
-Root cause:
-Rival considered:
-Discriminator: <the executed observation that separated them>
-Fix:
-Verification:
-Remaining risk:
-```
-
-Do not present a guess as a root cause. A root cause with no rival considered and no executed discriminator is a guess. If no root cause is proven, report the missing evidence.

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

@@ -1,4 +0,0 @@
-interface:
-  display_name: "SCIP Debug"
-  short_description: "Root-cause bugs with scip-query evidence"
-  default_prompt: "Use scip-query to trace a bug from entry point to root cause, propose a minimal fix, and verify the blast radius."

package/skills/scip-diagram/SKILL.md

@@ -1,110 +0,0 @@
----
-name: scip-diagram
-description: Diagram code with scip-query evidence. Use for code flow diagrams, architecture diagrams, data-flow maps, dependency maps, blast-radius visuals, module maps, or HTML artifacts explaining a system.
-commands:
-  - template: 'scip-query system <module>'
-    when: 'Collect evidence: module map for a dependency or architecture diagram.'
-  - template: 'scip-query trace <symbol>'
-    when: 'Collect evidence: definition plus references for a call-flow diagram.'
-  - template: 'scip-query call-graph <symbol>'
-    when: 'Collect evidence: callers/callees for a call-flow diagram.'
-  - template: 'scip-query dataflow <symbol>'
-    when: 'Collect evidence: producers/consumers for a data-flow diagram.'
-  - template: 'scip-query affected <symbol> --json'
-    when: 'Collect evidence: blast-radius nodes and edges.'
-  - template: 'scip-query change-surface <file> --json --full'
-    when: 'Collect evidence: exports and consumers for a change-surface map.'
----
-
-# scip-diagram
-
-Use this skill to build a visual explanation from compiler-resolved facts. A code diagram is an HTML artifact that turns source units, calls, dependencies, data flow, or blast radius into a visual map; every node and edge must trace to scip-query evidence.
-
-Load shared mechanics from [`../_shared/SKILL.md`](../_shared/SKILL.md).
-
-<!-- BEGIN GENERATED SKILL COMMANDS -->
-## Commands for this skill
-
-| Command | Purpose | Returns | Coverage | When |
-| --- | --- | --- | --- | --- |
-| `scip-query system <module>` | Full module map: files, symbols, deps in/out | module file paths; exported symbols with line ranges; internal dependencies; reverse dependencies | `complete` | Collect evidence: module map for a dependency or architecture diagram. |
-| `scip-query trace <symbol>` | Trace a symbol: definition + all references | definition sites with source and signature; referencing files with line numbers | `bounded` | Collect evidence: definition plus references for a call-flow diagram. |
-| `scip-query call-graph <symbol>` | Show incoming callers and outgoing callees for a symbol | caller and callee symbol identities with files | `bounded` | Collect evidence: callers/callees for a call-flow diagram. |
-| `scip-query dataflow <symbol>` | Reference-level dataflow: definition sites, usage sites, producers, consumers | definition sites, usage sites, producer symbols, and consumer symbols | `bounded` | Collect evidence: producers/consumers for a data-flow diagram. |
-| `scip-query affected <symbol> --json` | Transitive closure of symbols that could break if this symbol changes | affected symbol identities, files, and traversal depths | `bounded` | Collect evidence: blast-radius nodes and edges. |
-| `scip-query change-surface <file> --json --full` | Pre-change briefing: exports, consumers, and blast-radius risk | defined symbols, external consumer counts, and risk levels | `bounded` | Collect evidence: exports and consumers for a change-surface map. |
-
-Use this shortlist first. Open [`../_shared/SKILL.md`](../_shared/SKILL.md) only when it is insufficient.
-<!-- END GENERATED SKILL COMMANDS -->
-
-## Rules
-
-1. Run evidence before drawing.
-2. Default to a self-contained HTML file.
-3. Include command provenance in the artifact.
-4. Scope large graphs into clusters instead of rendering a hairball.
-5. Verify the HTML opens and the diagram is nonblank.
-
-## Workflow
-
-### 1. Pick diagram type
-
-| User wants                 | Diagram                          |
-| -------------------------- | -------------------------------- |
-| Feature flow               | Call flow                        |
-| Value origin or mutation   | Data flow                        |
-| Dependents                 | Blast radius                     |
-| Module architecture        | Dependency map                   |
-| Hard-to-change explanation | Change surface or bottleneck map |
-| Classes or ownership       | Hierarchy and surface map        |
-
-This step is complete only when the diagram's node and edge types are chosen.
-
-### 2. Collect evidence
-
-Use only commands needed for the chosen diagram:
-
-```bash
-scip-query system <module>
-scip-query surface <module>
-scip-query outline <file>
-scip-query trace <symbol>
-scip-query code <symbol>
-scip-query call-graph <symbol>
-scip-query dataflow <symbol>
-scip-query slice <symbol>
-scip-query slice <symbol> --forward
-scip-query deps <file>
-scip-query rdeps <file>
-scip-query affected <symbol> --json
-scip-query change-surface <file> --json --full
-scip-query hierarchy <symbol> --json
-scip-query fan-out <file> --json
-```
-
-This step is complete only when every planned node and edge has a source command.
-
-### 3. Build the artifact
-
-Write to:
-
-```text
-docs/scip-query/diagrams/YYYY-MM-DD-<scope>.html
-```
-
-Include title, scope, summary, visual diagram, legend, evidence table, omitted/collapsed nodes, and unavailable capabilities.
-
-Use inline CSS and semantic HTML or inline SVG. Give stable dimensions, wrapping labels, accessible colors, and distinct edge styles for calls, data, dependencies, and risk.
-
-This step is complete only when the HTML contains the visual and provenance table.
-
-### 4. Verify
-
-Open the file locally or use a browser/screenshot tool when available. Confirm:
-
-- diagram is nonblank;
-- labels do not overlap badly;
-- major nodes and edges trace to evidence;
-- `scip-verify` has been invoked when this is part of a docs/code change.
-
-End with the file path and what the diagram proves.

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

@@ -1,4 +0,0 @@
-interface:
-  display_name: "SCIP Diagram"
-  short_description: "Create HTML code-flow diagrams from scip-query"
-  default_prompt: "Generate an HTML diagram that explains this code path using scip-query evidence and command provenance."

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

@@ -1,266 +0,0 @@
----
-name: scip-directory-architecture
-description: Review directory architecture with scip-query evidence. Use to evaluate, design, reorganize, or migrate folder structure, ownership boundaries, locality config, messy repos, AI-generated layout, or safe file-move slices.
-commands:
-  - template: 'scip-query system <scope>'
-    when: 'Inventory evidence: files, symbols, deps in/out for the scope.'
-  - template: 'scip-query locality-candidates --json --full'
-    when: 'Inventory evidence: directory-locality candidates from consumer ownership.'
-  - template: 'scip-query similar-files --full --json'
-    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.'
----
-
-# scip-directory-architecture
-
-Use this skill to answer where code should live. Directory architecture is the filesystem arrangement of source files by their main reason to change; what distinguishes a good structure is that a maintainer can predict where a concept belongs before reading every import.
-
-Load shared mechanics from [`../_shared/SKILL.md`](../_shared/SKILL.md).
-
-<!-- BEGIN GENERATED SKILL COMMANDS -->
-## Commands for this skill
-
-| Command | Purpose | Returns | Coverage | When |
-| --- | --- | --- | --- | --- |
-| `scip-query system <scope>` | Full module map: files, symbols, deps in/out | module file paths; exported symbols with line ranges; internal dependencies; reverse dependencies | `complete` | Inventory evidence: files, symbols, deps in/out for the scope. |
-| `scip-query locality-candidates --json --full` | Find directory-locality and ancestry candidates from consumer ownership | symbols, current homes, consumer locality, and suggested homes | `bounded` | Inventory evidence: directory-locality candidates from consumer ownership. |
-| `scip-query similar-files --full --json` | Find heuristic similar-file candidates from dependency profiles | file pairs with similarity scores and shared symbols | `bounded` | Inventory evidence: files with overlapping dependency profiles. |
-| `scip-query cycles` | Detect circular dependency chains between files | dependency-cycle file chains | `bounded` | Inventory evidence: circular dependency chains between files. |
-| `scip-query architecture --json` | Evaluate project-owned architectural boundaries and dependency rules | boundary coverage and dependency-rule violations | `complete` | 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 | drifted symbol families, files, and evidence | `bounded` | 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 | file pairs, co-change counts, confidence, and history context | `bounded` | Inventory evidence: hidden file-level coupling from git history. |
-| `scip-query health --write-baseline` | Composite codebase health report with prioritized action list | health score, findings, priorities, baselines, and coverage notes | `bounded` | 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 | blocking findings with check id, message, and remediation; advisory findings; root-cause groups; changed file and symbol counts; process exit status (1 when blocking findings exist) | `bounded` | 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 | validation diagnostics with config paths | `complete` | 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.
-<!-- END GENERATED SKILL COMMANDS -->
-
-## Terms
-
-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.
-
-A slop codebase is a codebase whose files are arranged by accident, convenience, or recent edits rather than stable ownership rules.
-
-## Rules
-
-1. Start with evidence, not taste.
-2. Separate review from migration; do not move files unless asked.
-3. Preserve broad boundaries when evidence shows they are intentional.
-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
-
-### 1. Bound the question
-
-Classify the request: review, target structure, locality config, migration plan, or implementation.
-
-This step is complete only when the scope and deliverable are explicit.
-
-### 2. Inventory evidence
-
-```bash
-scip-query stats
-scip-query system <scope>
-scip-query files <pattern>
-scip-query surface <scope>
-scip-query deps <file>
-scip-query rdeps <file>
-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
-scip-query recent-duplicates
-scip-query drift
-```
-
-Also read durable project guidance that names architecture, modules, ownership, routes, workflows, contracts, or domains.
-
-This step is complete only when each folder under review has evidence for exports, entry points, consumers, tests, co-change partners, and claimed ownership rules.
-
-### 3. Classify boundary maturity
-
-Classify each candidate:
-
-- Mature: repeated, documented, and enforced by imports, tests, routes, packages, standards, or review history.
-- Emerging: meaningful and partly repeated, but not consistent enough to configure.
-- Accidental: convenience bucket, legacy pile, generated artifact, recent edit cluster, or mixed reasons to change.
-
-This step is complete only when mature, emerging, and accidental boundaries are separated.
-
-### 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:
-
-```markdown
-# Directory Architecture Review
-
-## Scope
-
-## Current Structure Map
-
-## Boundary Maturity
-
-## Descriptive Architecture Model
-
-## Dependency Rules
-
-## Forbidden-Edge Ledger
-
-## Reciprocal and Cycle Review
-
-## Target Structure
-
-## Move Ledger
-
-## Locality Config
-
-## No-Move Decisions
-
-## Deferred Decisions
-
-## Migration Order
-```
-
-List no-move decisions when broad consumers, route/package/contract surfaces, infrastructure roles, generic shared risk, or weak evidence make a move harmful.
-
-This step is complete only when every proposed move has a reason and verification path.
-
-### 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:
-
-```bash
-scip-query incomplete-migration
-scip-query recent-duplicates
-scip-query co-change <moved-file-or-config>
-```
-
-Also run project tests or typecheck for the affected workspace. If `.scipquery.json` locality changed, run:
-
-```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-directory-architecture/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "SCIP Directory Architecture"
-  short_description: "Review and propose source folder boundaries"
-  default_prompt: "Use $scip-directory-architecture to review this repository directory structure and propose safer ownership boundaries."

package/skills/scip-doc-reconcile/SKILL.md

@@ -1,89 +0,0 @@
----
-name: scip-doc-reconcile
-description: Reconcile living docs with current code using scip-query doc-drift. Use for stale standards, broken file references, docs that cite moved code, agent guidance, or normative contradictions between documentation and implementation.
-commands:
-  - template: 'scip-query doc-drift --json --full'
-    when: 'Build the worklist: every stale-doc candidate, ranked.'
-  - template: 'scip-query doc-drift <doc>'
-    when: 'Reconcile one doc: staleness detail for a single target.'
-  - template: 'scip-query outline <subject-file>'
-    when: 'Reconcile one doc: current shape of the code the doc describes.'
-  - template: 'scip-query trace <symbol>'
-    when: 'Reconcile one doc: verify a symbol the doc mentions still exists as described.'
-  - template: 'scip-query code <symbol>'
-    when: 'Reconcile one doc: re-derive a snippet from current source.'
----
-
-# scip-doc-reconcile
-
-Use this skill to make living documentation true again. A living doc is documentation agents or maintainers use to make present-day changes, such as AGENTS.md, CLAUDE.md, standards, command docs, or workflow docs.
-
-Load shared mechanics from [`../_shared/SKILL.md`](../_shared/SKILL.md).
-
-<!-- BEGIN GENERATED SKILL COMMANDS -->
-## Commands for this skill
-
-| Command | Purpose | Returns | Coverage | When |
-| --- | --- | --- | --- | --- |
-| `scip-query doc-drift --json --full` | Stale-doc candidates: code the doc references or co-changed with kept changing after the doc stopped | document paths, coupled code subjects, and history evidence | `bounded` | Build the worklist: every stale-doc candidate, ranked. |
-| `scip-query doc-drift <doc>` | Stale-doc candidates: code the doc references or co-changed with kept changing after the doc stopped | document paths, coupled code subjects, and history evidence | `bounded` | Reconcile one doc: staleness detail for a single target. |
-| `scip-query outline <subject-file>` | Tree view of symbols in a file, with line ranges | symbol names, nesting, and line ranges | `complete` | Reconcile one doc: current shape of the code the doc describes. |
-| `scip-query trace <symbol>` | Trace a symbol: definition + all references | definition sites with source and signature; referencing files with line numbers | `bounded` | Reconcile one doc: verify a symbol the doc mentions still exists as described. |
-| `scip-query code <symbol>` | Read the source code for a symbol (bounded to its definition range) | definition identity, source, and line range | `complete` | Reconcile one doc: re-derive a snippet from current source. |
-
-Use this shortlist first. Open [`../_shared/SKILL.md`](../_shared/SKILL.md) only when it is insufficient.
-<!-- END GENERATED SKILL COMMANDS -->
-
-## Rule
-
-Separate statement types:
-
-- Descriptive claims say what the code currently does or where it lives. Update them when code moves.
-- Normative claims say what code must or should do. If code violates them, fix the code or escalate the contradiction; do not weaken the standard silently.
-
-This distinction is the core of doc reconciliation.
-
-## Workflow
-
-### 1. Build the worklist
-
-```bash
-scip-query doc-drift --json --full
-scip-query doc-drift <doc-or-tree>
-```
-
-Prioritize broken references, highest staleness, then docs agents read most. Do not reconcile archival records such as dated plans, ADRs, or reports — list them in `.scipquery.json` `docs.snapshotPaths` so `doc-drift` excludes them with a labeled exclusion instead of resurfacing them every sweep.
-
-This step is complete only when each target doc is selected for a current-use reason.
-
-### 2. Reconcile one doc
-
-For each doc:
-
-```bash
-scip-query doc-drift <doc>
-scip-query outline <subject-file>
-scip-query system <module>
-scip-query trace <symbol-the-doc-mentions>
-scip-query code <symbol>
-```
-
-Use Git history only to understand why a subject changed, not as a substitute for current code evidence.
-
-Fix broken references by finding the current code or deleting the obsolete claim. Rewrite stale descriptive claims from current source evidence. Re-derive snippets from `scip-query code`. Record normative contradictions instead of changing standards to bless drifted code.
-
-This step is complete only when every edited claim is supported by evidence from this session.
-
-### 3. Verify
-
-```bash
-scip-query doc-drift <doc>
-```
-
-Invoke `scip-verify` when the documentation change is part of a codebase diff. The doc is complete only when staleness drops to zero or the remaining contradiction is explicitly reported.
-
-### 4. Report
-
-Report staleness before and after, broken references fixed, claims updated, normative contradictions, and docs recommended for deletion.
-
-Do not claim reconciliation is done until `doc-drift` has been rerun.

package/skills/scip-doc-reconcile/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "SCIP Doc Reconcile"
-  short_description: "Repair docs that drift from code"
-  default_prompt: "Use $scip-doc-reconcile to reconcile this documentation with current SCIP-backed code evidence."