diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e992379..b690251 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -15,10 +15,18 @@ jobs: - uses: actions/checkout@v7.0.1 - uses: actions/setup-python@v7.0.0 with: - python-version: "3.x" + python-version: "3.13" - uses: actions/setup-node@v6 with: node-version: "24.15.0" + - name: Install pinned native-reader runtimes + run: | + python -m pip install -r msdmd/requirements.txt + npm ci --ignore-scripts --prefix msdmd + - name: Native collection drift and TypeScript schema + run: | + python -m msdmd.collect --root . --repo The-Interdependency/skill-lib --snapshot-identity --import-path ./msdmd/collection --out skill-lib_msdmd.ts --strict --check + node msdmd/node_modules/typescript/bin/tsc --noEmit --strict --skipLibCheck --target ES2022 --module commonjs msdmd/collection.ts skill-lib_msdmd.ts - name: Unit tests run: python -m unittest discover -s tests - name: Gonol authority gate diff --git a/.gitignore b/.gitignore index 4d54493..91f2f9b 100644 --- a/.gitignore +++ b/.gitignore @@ -13,3 +13,6 @@ __pycache__/ # Local secrets .env + +# Pinned native parser runtime; install with npm ci --prefix msdmd +msdmd/node_modules/ diff --git a/README.md b/README.md index 0f2f05b..6fe780c 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ into [`llms.txt`](llms.txt) from self-declared `LLMS` blocks. | Skill | Purpose | |---|---| -| [`msdmd/`](msdmd/SKILL.md) | The foundational native-first metadata contract: convention discovery, provenance, conflicts, information coverage, and supplemental block syntax. The block collector remains block-only; a separate partial Python reader emits deterministic per-module symbol/docstring/comment projections. | +| [`msdmd/`](msdmd/SKILL.md) | The foundational native-first metadata contract: convention discovery, provenance, conflicts, information coverage, and supplemental block syntax. The schema-2 collector integrates native source/document readers with qualified identities, required-fact policies and explicit unknowns; Python module projections share its attachment reader. | | [`doc-build/`](doc-build/SKILL.md) | Applies native-first msdmd to documentation comments and source-linked documents; supplemental `DOCS` entries cover remaining obligations. Reader support and missing information stay distinct. | | [`cap-build/`](cap-build/SKILL.md) | Consumes native signatures, exports and API schemas; supplemental `CAPABILITIES` entries add otherwise unexpressed intent. Declared surfaces are not verified behavior. | | [`deps-build/`](deps-build/SKILL.md) | Consumes native imports, manifests and build metadata at their owning scopes; supplemental `DEPENDENCIES` entries add remaining architectural intent. | diff --git a/agent-instantiation/SKILL.md b/agent-instantiation/SKILL.md index ac5f73c..7b44799 100644 --- a/agent-instantiation/SKILL.md +++ b/agent-instantiation/SKILL.md @@ -1,6 +1,6 @@ --- name: agent-instantiation -description: Methodology for instantiating, forking, running, merging, and retiring agents in the a0 platform and its near-identical mirror a0ucns. Load this when adding or changing a sub-agent spawn path, a PCNA instance fork/merge, an agent definition or naming scheme, spawn caps or approval gating, an agent run/log table, a heartbeat-driven agent task, or a checkpoint of agent state. Use it before writing any code that creates, addresses, schedules, or tears down an agent or sub-agent, so the new code follows the platform's existing lifecycle, fork/merge, identity, and gating contracts rather than inventing a parallel one. NOTE: a0-betatest (a0p) has diverged to a different per-user CRUD + native-ZFAE instancing model — this skill's spawn/fork/merge sequence does NOT apply there; see "a0-betatest divergence". +description: Methodology for instantiating, forking, running, merging, and retiring agents in the a0 platform and its near-identical mirror a0ucns. Load this when adding or changing a sub-agent spawn path, a PCNA instance fork/merge, an agent definition or naming scheme, spawn caps or approval gating, an agent run/log table, a heartbeat-driven agent task, or a checkpoint of agent state. Use it before writing any code that creates, addresses, schedules, or tears down an agent or sub-agent, so the new code follows the platform's existing lifecycle, fork/merge, identity, and gating contracts rather than inventing a parallel one. NOTE — a0-betatest (a0p) has diverged to a different per-user CRUD + native-ZFAE instancing model — this skill's spawn/fork/merge sequence does NOT apply there; see "a0-betatest divergence". --- # agent-instantiation — How a0 brings agents into being diff --git a/cap-build/SKILL.md b/cap-build/SKILL.md index 1446b3a..d35fe74 100644 --- a/cap-build/SKILL.md +++ b/cap-build/SKILL.md @@ -10,8 +10,9 @@ agents and humans a source-backed inventory of declared capabilities, exposed surfaces and the boundaries they are declared to cross. Implementation status: this skill defines the `CAPABILITIES` block and runner -contract. This repo does not currently ship a CAPABILITIES runner or native -surface readers; consuming repos implement and test their applicable mappings. +contract. The MSDMD schema-2 collector ships a Python callable/class/export +reader, but no complete behavioral capability or framework/API-schema runner; +consuming repos implement and test their remaining mappings. Read `msdmd/SKILL.md` first. Its provenance, information-coverage, parser and explicit reader-support contracts apply. @@ -26,8 +27,8 @@ missing behavioral intent may still require a supplemental declaration. Keep syntactically observed surfaces, documented behavior, derived mappings and verified outcomes distinct. Unsupported surface discovery is `PENDING`, not -proof of either complete coverage or an absent capability. Native readers remain -implementation work, not capabilities supplied by this skill text. +proof of either complete coverage or an absent capability. Reader support beyond +the shipped source/standard subsets remains implementation work. ## The block @@ -112,5 +113,5 @@ Include same-name/different-scope, genuinely missing intent and unsupported-read hmmm - exact resolver syntax for framework-specific route and UI surfaces -- qualified identity and duplicate validation remain consuming-runner work +- application capability identity and semantic conflict policy remain consuming-runner work - whether private capabilities need a distinct class in the consuming policy diff --git a/deps-build/SKILL.md b/deps-build/SKILL.md index 0599252..12343a8 100644 --- a/deps-build/SKILL.md +++ b/deps-build/SKILL.md @@ -10,8 +10,9 @@ source-owned dependency edges and otherwise unexpressed architectural intent inspectable without demanding a second declaration of existing imports. Implementation status: this skill defines the `DEPENDENCIES` block and runner -contract. This repo does not currently ship a DEPENDENCIES graph runner or -native dependency readers; consuming repos implement and test local resolvers. +contract. The MSDMD schema-2 collector ships Python import, `package.json`, and +`pyproject.toml` dependency extraction, but no complete resolution/cycle runner; +consuming repos implement and test local resolvers and policies. Read `msdmd/SKILL.md` first. Its provenance, information-coverage, parser and explicit reader-support contracts apply. @@ -27,7 +28,7 @@ An import is not a call edge or a complete architecture explanation. A lockfile records a resolution, not every source-level usage. Collect the native edge as expressed; supplement missing intent only where policy actually requires it. Unsupported discovery/resolution remains `PENDING` / `hmmm`, not absent metadata. -Native readers are implementation work, not capabilities supplied by this text. +Reader support beyond the shipped subsets remains implementation work. ## The block @@ -117,4 +118,4 @@ unknown build conditions, genuinely missing intent and permitted/forbidden cycle hmmm - exact resolver syntax for cross-language call and route edges - which dependency classes disallow cycles by default -- native readers and qualified graph identities remain consuming-runner work +- cross-language resolution and application cycle policy remain consuming-runner work diff --git a/doc-build/SKILL.md b/doc-build/SKILL.md index a4010ce..260b651 100644 --- a/doc-build/SKILL.md +++ b/doc-build/SKILL.md @@ -9,8 +9,9 @@ description: Native-first documentation coverage built on msdmd. Consume docstri source-owned documentation obligations and their coverage inspectable. Implementation status: this skill defines the `DOCS` block and runner contract. -This repo does not currently ship a DOCS runner or native documentation readers; -consuming repos implement and test the contract against their documentation tree. +The MSDMD schema-2 collector ships structured Python docstrings, JSDoc, Rustdoc/Javadoc/Doxygen extraction +and nested Markdown-frontmatter readers, but no complete DOCS obligation/link/anchor runner. Consuming repos add +and test the policies and resolvers their documentation tree requires. Read `msdmd/SKILL.md` first. Its provenance, information-coverage, parser and explicit reader-support contracts apply. @@ -26,8 +27,8 @@ Policy determines which information each audience/surface actually requires. Missing descriptions, unresolved readers, broken links and block adoption are separate findings. Comments alone do not prove every documentation obligation is -met; lack of DOCS syntax does not prove documentation is missing. Native readers -remain implementation work, not capabilities supplied by this skill text. +met; lack of DOCS syntax does not prove documentation is missing. Reader support +outside the shipped manifest remains implementation work. ## The block diff --git a/llms.txt b/llms.txt index 1db876d..eb2f95e 100644 --- a/llms.txt +++ b/llms.txt @@ -5,7 +5,7 @@ skill-lib is the canonical organization-wide source for reusable agent skills in It provides msdmd-based metadata skills, procedural skills, pure-stdlib helper tools, and propagation guidance for consuming repositories. ## Key Definitions (never infer or expand these) -- **msdmd** = Module Self-Declared Metadata in Markdown — native-first collection of existing code, documentation, manifest, schema, tooling and evidence metadata; MSDMD blocks supply otherwise unexpressed information. The collector remains block-only; a separate partial Python reader projects symbols, docstrings and structurally attached comments. +- **msdmd** = Module Self-Declared Metadata in Markdown — native-first collection of existing code, documentation, manifest, schema, tooling and evidence metadata; MSDMD blocks supply otherwise unexpressed information. The schema-2 collector integrates native source and document readers with qualified provenance, structured docstrings, shared Python comment attachment and required-fact policies; unsupported scope remains explicit. - **char-compress** = Skill-lib-owned character-based context compression for agent handoff and skill writing; its historical bone/flesh and text-stack notation is not current UCNS mathematics. - **llms-build** = LLM instruction publication from owning metadata; the shipped runner generates root llms.txt from LLMS blocks, while native-reader integration remains a contract. diff --git a/llms/metadata.py b/llms/metadata.py index 77ed5a0..b1f2d7a 100644 --- a/llms/metadata.py +++ b/llms/metadata.py @@ -7,7 +7,7 @@ # It provides msdmd-based metadata skills, procedural skills, pure-stdlib helper tools, and propagation guidance for consuming repositories. # # id: key_definitions -# msdmd: Module Self-Declared Metadata in Markdown — native-first collection of existing code, documentation, manifest, schema, tooling and evidence metadata; MSDMD blocks supply otherwise unexpressed information. The collector remains block-only; a separate partial Python reader projects symbols, docstrings and structurally attached comments. +# msdmd: Module Self-Declared Metadata in Markdown — native-first collection of existing code, documentation, manifest, schema, tooling and evidence metadata; MSDMD blocks supply otherwise unexpressed information. The schema-2 collector integrates native source and document readers with qualified provenance, structured docstrings, shared Python comment attachment and required-fact policies; unsupported scope remains explicit. # char-compress: Skill-lib-owned character-based context compression for agent handoff and skill writing; its historical bone/flesh and text-stack notation is not current UCNS mathematics. # llms-build: LLM instruction publication from owning metadata; the shipped runner generates root llms.txt from LLMS blocks, while native-reader integration remains a contract. # diff --git a/meta-module-build/SKILL.md b/meta-module-build/SKILL.md index f3507e6..b3141f7 100644 --- a/meta-module-build/SKILL.md +++ b/meta-module-build/SKILL.md @@ -13,8 +13,9 @@ notes attributable to the sources that own them. Read `msdmd/SKILL.md` first. This skill inherits its source/provenance, native reader support, supplemental block and information-coverage contracts. -Implementation status: this is a consuming-repo planning/runner contract; -this repo does not ship a MODULE_BUILD runner or native planning readers. +Implementation status: this is a consuming-repo planning/runner contract. The +MSDMD schema-2 collector preserves JSON and TOML manifest trees, but this repo +does not ship a complete MODULE_BUILD obligation/policy runner. ## Doctrine @@ -35,8 +36,8 @@ not automatically a module plan: map only information it actually expresses. The build's semantic obligations remain required, but their native owners need no MODULE_BUILD copies. Supplement genuinely unexpressed intent. Unsupported -mapping is unresolved coverage, not absence. Native readers remain implementation -work, not capabilities supplied by this text. +mapping is unresolved coverage, not absence. Semantic planning mappings beyond +the shipped structured-source preservation remain implementation work. ## The block @@ -204,7 +205,7 @@ no boundary/test plan remains incomplete. ## hmmm -Native planning readers remain consuming-repo implementation work. +Native planning-obligation mappings remain consuming-repo implementation work. Default unresolved items for new modules: ```text diff --git a/msdmd/SKILL.md b/msdmd/SKILL.md index 5386653..fa8be15 100644 --- a/msdmd/SKILL.md +++ b/msdmd/SKILL.md @@ -21,15 +21,23 @@ This is the foundational metadata-block skill, expanded to native-first interoperability; it owns the common ingestion contract, not every language's syntax. Ordinary prose editing with no metadata contract is a non-trigger. -**Implementation boundary:** `collect.py` still implements MSDMD-block collection -and `collection.ts` still represents block-origin declarations. The separate -`module_projection.py` runner now implements a partial Python native-reader slice: -AST symbols and signatures, decorators, docstrings, and structurally attached -line comments are projected to versioned per-module JSONL. It does not integrate -those facts into `collection.ts`, interpret every Python metadata convention, or -establish repository-wide information coverage. The broader provenance, -conflict, reconciliation, discovery, and multi-language requirements below -remain contracts for implementation. +**Implemented boundary:** `collect.py` defaults to schema 2 and integrates native +facts and supplemental blocks in `collection.ts`. The registry in `readers.py` +declares each shipped extraction subset. Python uses the same syntax-aware +attachment implementation as `module_projection.py`; TypeScript uses its compiler +API; Rust, Java, C and C++ use pinned syntax grammars. Structured standards feed +this same collector, not separate disconnected reports. See the executable +[reader support matrix](references/implemented-readers.md) before asserting coverage. + +Install the declared parser runtimes once: + +```bash +python -m pip install -r msdmd/requirements.txt +npm ci --ignore-scripts --prefix msdmd +``` + +Missing dependencies become unsupported-reader diagnostics, never empty success. +The universal MSDMD block parsers themselves remain dependency-free. ## Doctrine @@ -113,15 +121,16 @@ source. Sensitive material stays access-controlled or explicitly redacted; source preservation does not require publishing credentials or private content. Do not repurpose `MsdmdDeclaration.block` to mean JSDoc, TOML, or any other -non-block convention. Introduce a versioned native-capable collection schema +non-block convention. `MsdmdCollectionV2` provides the native-capable schema with explicit migration and consumer negotiation. The existing `MsdmdCollection` -remains a block-only format until that implementation lands. Refuse silent +name remains a schema-1 compatibility type, never a native-fact container. Refuse silent projection when an old consumer would lose required information. ### Python per-module projection -`module_projection.py` is a bounded native reader, not the universal collection -promised by the full contract. It parses supplied `.py` bytes with `ast` and +`module_projection.py` owns the shared Python attachment reader. The schema-2 +collector invokes `project_python_bytes` on its bounded source buffer; the +standalone sidecar CLI remains an optional view of the same attachment facts. It parses supplied `.py` bytes with `ast` and `tokenize` and never imports the inspected module. Its JSONL schema is `module-projection.schema.json`; its machine-readable support manifest is `python-module-reader.json`. The first record binds repository context, source @@ -184,11 +193,11 @@ python -m msdmd.module_projection --root . --repo example/repo \ ``` Use repeatable `--source path/to/module.py` arguments for an incremental subset. -Current non-goals include import/dependency extraction, call graphs, dynamic -exports, docstring-dialect field parsing, `.pyi` semantics, cross-revision rename -mapping, other languages, and integration with the block collection/visualizer. -Those unsupported surfaces remain `hmmm`; the presence of this reader does not -upgrade them. +The standalone sidecar schema remains focused on attachment. The integrated +Python reader additionally extracts imports, literal exports, SPDX headers and +ReST/Google/NumPy docstring fields. Neither path supplies a call graph, evaluated +dynamic exports, cross-revision rename mapping or runtime proof. Stub syntax is +parsed without claiming complete `.pyi` semantics. ## The runner protocol @@ -248,12 +257,11 @@ IDs to be unique within one block type in one owning file; multiple matching blocks concatenate. A conforming identity validator must diagnose conflicting IDs and qualify collection addresses by repository, file, block and entry. -**That validation is not implemented by the shipped helpers.** The generic -collector does not diagnose duplicate IDs, and its edge `from` and `source_id` -values are bare entry IDs. The visualizer can merge distinct declarations when -IDs are reused across files or block types. Do not treat a successful collection -exit or its graph as evidence of identity validity. See the -[shipped helper limitations](#shipped-helper-limitations). +The schema-2 collector diagnoses duplicate IDs within one file/block, qualifies +addresses by repository/revision/file/block/id and qualifies edge endpoints. +Ambiguous references remain unresolved with all candidate witnesses. The +visualizer uses those qualified addresses instead of collapsing same-name nodes. +The universal text parser alone still only parses syntax; it is not a validator. Use the helpers' matching `COMMENT_MARKERS` registries for supported repeated line-comment syntax; do not duplicate their language lists in runners. Native @@ -302,49 +310,73 @@ blocks need to be inserted. The return annotation is a declaration, not a test result. CODEOWNERS review responsibility is not automatically authorship, operational ownership, or proof of a team's live permissions. -The partial Python projection can recover the example function signature and -docstring. It cannot yet recover the TOML package fields or CODEOWNERS rule, and -neither it nor the block collector can issue a repository-wide native-information -coverage verdict. Report those reader gaps explicitly. +The integrated collector recovers all three native sources in this example. +Required information still needs an explicit policy; signatures, review rules +and package identity do not imply complete behavioral or operational coverage. ## Repo collection point and visualizer -### Existing helper usage - -`skills.json` retains `status: runnable` and `runner: msdmd/collect.py` for -shipped block collection. `runner_scope: msdmd-blocks-only` bounds that capability; -`native_ingestion.status: partial` points to the separate Python module-projection -runner and names its bounded scope. Neither index field upgrades the other -helper's behavior. +### Native-capable runner usage -These commands collect and visualize **MSDMD blocks only**: +`skills.json` identifies `msdmd/collect.py` as the native-and-supplemental runner. +The generated `_msdmd.ts` is disposable, never manually maintained. +Its `gaps` records supplemental block adoption, not native-information absence. +Every output includes the registry manifests, source digests, reader runs, +discovery ledger, facts, declarations, qualified edges, conflicts and diagnostics. ```bash -python -m msdmd.collect --root . --repo example --out example_msdmd.ts +python -m msdmd.collect --root . --repo example --out example_msdmd.ts --strict python -m msdmd.visualize example_msdmd.ts --out example_msdmd.mmd ``` -The existing collection's `gaps` field records expected-block gaps only. -`--expected-block` measures block presence, not native metadata completeness. -Do not use its output as the new information-coverage gate. Repo-level collection -points such as `_msdmd.ts` remain generated consumers of owning sources, -not editable replacements for them. The separate Python command above emits -`.msdmd.jsonl` sidecars and does not alter that TypeScript collection. +For a checked-in reproducible collection, use `--snapshot-identity` to bind facts +to the exact configured source-byte snapshot rather than the commit containing +the generated output. Excluded subtree rules, rather than transient cache +directory presence, are recorded in this snapshot mode. `--check` recomputes and compares bytes without writing: + +```bash +python -m msdmd.collect --root . --repo The-Interdependency/skill-lib \ + --snapshot-identity --import-path ./msdmd/collection --out skill-lib_msdmd.ts --strict +python -m msdmd.collect --root . --repo The-Interdependency/skill-lib \ + --snapshot-identity --import-path ./msdmd/collection --out skill-lib_msdmd.ts --strict --check +``` + +Source revision, worktree state and byte digests remain separate. A snapshot is +not producer authentication. Excluded output paths are configured even before +their first write, preventing generation from changing its own source identity. + +### Required information and disclosure + +`--expected-block` measures block adoption only. `--require-source GLOB` demands +complete extraction for each matching file. Repeat `--require-fact` to require +source-linked witnesses from a named native convention and kind: + +```bash +python -m msdmd.collect --root . --repo example --json --strict \ + --require-source 'package.json' \ + --require-fact 'package.json::npm.package-json::dependency' +``` + +With a required policy, no matches, invalid sources, missing runtimes, ambiguous +syntax or unresolved extraction fail strict mode. Without a policy, optional +unknowns remain visible; a successful inventory is not a full-coverage verdict. +Parse errors and identity conflicts always invalidate strict collection. Native +facts and blocks remain separate; no universal precedence overwrites disagreements. -### Shipped helper limitations +Directory-descriptor discovery does not follow symlinks. It accounts for ignored +subtrees, unsupported inputs, byte limits and read errors. This safety path +requires POSIX no-follow directory-descriptor support. Secret-named files are +excluded; sensitive structured fields and URL credentials are redacted. This is +not a complete secret detector: public release still requires audience review. +The configured denominator never implies that excluded subtrees were inspected. -The declarations preserve `file`, `block` and `id`, but the current edge format -omits source-file identity and uses bare IDs; the Mermaid view can collapse -cross-file or cross-block identities. Duplicate IDs inside one file/block are -emitted without diagnostics. Qualified addresses and duplicate-ID validation -are required future validator behavior, not shipped guarantees. +### Consumer transition -Until implemented and tested with an explicit compatible schema/consumer -transition, use these helpers only for the disclosed inventory/prototype scope. -An identity-sensitive audit needs an independent, capable validator and an -unambiguous target-resolution policy. Without them, that required scope is -`hmmm`; a zero exit code cannot make it pass. This skill revision does not repair -the collector or visualizer runtime. +Schema 2 is the default. `--legacy-blocks-only` explicitly requests schema 1 for +existing block-only consumers; native requirements are rejected with that flag. +No native data is silently flattened into legacy block fields. The visualizer +supports both versions. Application-specific documentation renderers, ownership +policy and runtime witnesses retain their own semantics and acceptance gates. ## Validation and acceptance @@ -381,19 +413,14 @@ ratios/LLMS/frontend skill; preserve that application's semantic obligations. ## Versioning and migration -This revision supersedes the block-only ingestion/coverage doctrine, not the -stable block grammar. Keep native-reader versions, convention versions, collection -schema versions, and application versions distinct. Ship schema migration, -consumer updates, and tests together when native ingestion is implemented; -remove superseded routes rather than leaving contradictory active defaults. +The stable supplemental block grammar is unchanged. Native readers, schema, +projection mappings and dependencies have explicit versions. Schema-1 output is +an intentional compatibility operation, not a second default scanner. ## hmmm -The skill requires native-first ingestion across all applicable conventions. -The block collector and collection schema still implement their narrower path -without qualified edge identities or duplicate-ID diagnostics. One partial -Python reader now has executable fixtures, but import/dependency facts, docstring -dialects, other languages, repository discovery and exclusion receipts, conflict -handling, identity validation, and the unified collection migration remain to -be implemented and verified. Unknown conventions remain visible extensions of -scope, not imaginary completed support. +The shipped matrix defines extraction subsets, not every metadata standard. +Unimplemented conventions remain visible in discovery. `.h` language ambiguity, +macro/build/configuration expansion, full TSDoc validation, cross-source semantic +conflict resolution, ownership applicability and independent attestation/runtime +verification require their owning policies. None is inferred from a clean parse. diff --git a/msdmd/collect.py b/msdmd/collect.py index 42524e9..390afb6 100644 --- a/msdmd/collect.py +++ b/msdmd/collect.py @@ -1,41 +1,72 @@ -# ratios: loc_comments=143:28 imports_exports=6:3 calls_definitions=35:6 +# ratios: loc_comments=706:54 imports_exports=17:5 calls_definitions=213:21 # === DOCS === # id: msdmd_foundational_contract # source: msdmd/SKILL.md # catalogue: msdmd/references/metadata-conventions.md -# summary: Native-first metadata and information-coverage contract; supplemental blocks express otherwise unexpressed information. This source link is not native extraction of the skill or catalogue. +# summary: Native-first metadata collection with source-qualified facts, diagnostics, and coverage policy. Supplemental blocks express otherwise unexpressed information. # === END DOCS === # === CAPABILITIES === # id: repo_collection_generator -# exposes: collect, render_typescript -# summary: Generates block-only TypeScript collections from lexical source blocks using the canonical parser; not native discovery or identity validation. -# runner_scope: msdmd-blocks-only -# native_ingestion: contract -# unresolved: hmmm: native readers, qualified edge identities, duplicate-ID validation, native-capable schema migration, and executable native acceptance fixtures remain separate implementation work. -# limitations: Native files outside COMMENT_MARKERS are uncollected; skip paths and read errors are not inventoried; matching blocks in strings and test fixtures can be collected. Empty gaps without expected_blocks is not complete coverage. +# exposes: collect, render_typescript, collection_errors +# summary: Produces schema-2 collections from registered native readers and supplemental blocks without executing inspected sources. +# runner_scope: native-and-supplemental-blocks +# native_ingestion: implemented-tested-subsets +# limitations: Supported features and versions are reader-qualified; declarations and parsed reports do not prove runtime behavior. Required-source policy detects incomplete extraction. # === END CAPABILITIES === -"""Generate repo-level msdmd collection-point TypeScript. +# === MODULE_BUILD === +# id: msdmd_collection_generator +# module_name: collect +# module_kind: instrument +# summary: produces versioned native-first MSDMD collections without executing inspected sources +# owner: The Interdependency skill-lib +# public_surface: collect, collect_legacy, collection_errors, render_typescript +# internal_surface: bounded discovery, block identity validation, edge reconciliation, coverage accounting +# auth_boundary: none +# storage_boundary: read +# network_boundary: none +# user_data_boundary: read +# admin_only: false +# tests: tests/test_collect.py, tests/test_native_collection.py +# rollout: schema 2 is the default CLI output; --legacy-blocks-only keeps explicit schema 1 compatibility +# rollback: use --legacy-blocks-only while preserving schema incompatibility visibility +# === END MODULE_BUILD === +"""Generate a versioned native-first MSDMD collection. -This is a small stdlib helper for consuming repos that want to generate a -`_msdmd.ts` aggregation file from module-local msdmd blocks. -It uses the universal parser and emits data shaped by `msdmd/collection.ts`. +Usage guidance: + python -m msdmd.collect --root . --repo owner/repo --out repo_msdmd.ts + python -m msdmd.collect --root . --repo owner/repo --strict + python -m msdmd.collect --root . --repo owner/repo --legacy-blocks-only -Usage from this repository root (block-only lexical inventory): - python -m msdmd.collect --root . --repo The-Interdependency/skill-lib \ - --import-path ./msdmd/collection --out skill-lib_msdmd.ts - python -m unittest tests.test_msdmd_native_contract_docs - -Edit owning source blocks before regeneration. See ORG_DISTRIBUTION.md for -scope and docs/runner-config-guidance.md for the native discovery contract. +The default schema-2 path statically reads supported native conventions and +supplemental MSDMD blocks. It never imports inspected code, executes scripts, +loads plugins, follows network references, or treats declarations as verified +behavior. The explicit legacy flag emits the previous block-only shape for old +consumers; it cannot silently represent native facts. """ from __future__ import annotations import argparse +import fnmatch +import tempfile +import hashlib import json +import os +import stat +import subprocess +import io +import tokenize +from collections import Counter, defaultdict from pathlib import Path -from typing import Iterable +from typing import Any, Iterable +from urllib.parse import quote + +from msdmd.parsers.universal import marker_for, parse_text +from msdmd.readers import READER_MANIFESTS, _redact_sensitive, read_native -from msdmd.parsers.universal import walk_tree +SCHEMA_ID = "the-interdependency.msdmd-collection" +SCHEMA_VERSION = "2.0.0" +LEGACY_SCHEMA_VERSION = "1.0.0" +DEFAULT_MAX_FILE_BYTES = 2 * 1024 * 1024 DEFAULT_BLOCK_NAMES = ( "DOCS", @@ -46,7 +77,6 @@ "CHECKS", "MODULE_BUILD", "BOUNDARIES", - "RATIOS", "LLMS", "FRONTEND_META", ) @@ -61,42 +91,327 @@ "boundaries": "risk", } +_DEFAULT_SKIP = { + ".git", + ".agents", + ".skill-lib", + ".venv", + ".mypy_cache", + ".pytest_cache", + ".tox", + "__pycache__", + "build", + "dist", + "node_modules", + "target", + "venv", +} + + +def _sha256(data: bytes | str) -> str: + payload = data if isinstance(data, bytes) else data.encode("utf-8") + return hashlib.sha256(payload).hexdigest() + + +def _quote(value: str, *, path: bool = False) -> str: + return quote(value, safe="/" if path else "") + def _split_targets(value: str) -> list[str]: return [part.strip() for part in value.split(",") if part.strip()] -def _declaration(file: Path, root: Path, block: str, entry: dict) -> dict: - fields = {str(key): str(value) for key, value in entry.items() if key != "id"} +def _block_source_text(path: Path, text: str) -> str: + """Return only real Python comments, or unchanged non-Python source. + + The universal block grammar remains language-neutral. Python collection + adds syntax awareness here so block-shaped examples inside strings are not + collected as declarations. + """ + if path.suffix.lower() not in {".py", ".pyi", ".pyw"}: + return text + text = text.replace("\r\n", "\n").replace("\r", "\n") + comments = [""] * len(text.split("\n")) + try: + for token in tokenize.generate_tokens(io.StringIO(text).readline): + if token.type == tokenize.COMMENT: + comments[token.start[0] - 1] = token.string + except (tokenize.TokenError, IndentationError): + return "" + return "\n".join(comments) + + +def _decode_block_source(path: Path, data: bytes) -> str: + """Decode Python by its declared source encoding; other sources as UTF-8.""" + if path.suffix.lower() in {".py", ".pyi", ".pyw"}: + encoding, _ = tokenize.detect_encoding(io.BytesIO(data).readline) + return data.decode(encoding) + return data.decode("utf-8") + + +def _block_address(repo: str, revision: str, file: str, block: str, entry_id: str) -> str: + return ( + f"msdmd://{_quote(repo)}@{_quote(revision)}/{_quote(file, path=True)}" + f"#block/{_quote(block)}/{_quote(entry_id)}" + ) + + +def _block_declaration( + *, + file: str, + repo: str, + revision: str, + content_sha256: str, + block: str, + entry: dict[str, str], +) -> dict[str, Any]: + entry_id = str(entry["id"]) return { - "file": file.relative_to(root).as_posix(), + "address": _block_address(repo, revision, file, block, entry_id), + "origin": "msdmd-block", + "standing": "declared", + "source": { + "repository": repo, + "revision": revision, + "file": file, + "content_sha256": content_sha256, + "location": {"pointer": f"block:{block}/id:{entry_id}"}, + }, + "file": file, "block": block, - "id": str(entry["id"]), - "fields": fields, + "id": entry_id, + "fields": {str(key): str(value) for key, value in entry.items() if key != "id"}, } -def _edges_for(declaration: dict) -> list[dict]: - edges: list[dict] = [] - fields = declaration["fields"] - source = declaration["id"] +def _raw_block_edges(declaration: dict[str, Any]) -> list[dict[str, Any]]: + edges: list[dict[str, Any]] = [] for field, kind in EDGE_FIELDS.items(): - value = fields.get(field) + value = declaration["fields"].get(field) if not value or value == "hmmm": continue for target in _split_targets(value): - edges.append( - { - "from": source, - "to": target, - "kind": kind, - "source_block": declaration["block"], - "source_id": source, - } - ) + edges.append({ + "from": declaration["address"], + "to": target, + "kind": kind, + "standing": "declared", + "source_block": declaration["block"], + "source_id": declaration["address"], + "source_entry_id": declaration["id"], + "target_resolution": "pending", + }) return edges +def _git_identity(root: Path, explicit_revision: str | None) -> tuple[str, bool | str, str | None]: + revision = explicit_revision + dirty: bool | str = "hmmm" + git_head: str | None = None + try: + git_head = subprocess.run( + ["git", "-C", str(root), "rev-parse", "HEAD"], + check=True, + capture_output=True, + text=True, + ).stdout.strip() + if revision is None: + revision = git_head + status_output = subprocess.run( + ["git", "-C", str(root), "status", "--porcelain", "--untracked-files=all"], + check=True, + capture_output=True, + text=True, + ).stdout + input_changes = [] + for line in status_output.splitlines(): + changed_path = line[3:].split(" -> ")[-1].strip('"') if len(line) > 3 else "" + if not Path(changed_path).name.endswith("_msdmd.ts"): + input_changes.append(line) + dirty = bool(input_changes) + except (OSError, subprocess.CalledProcessError): + pass + return revision or "hmmm", dirty, git_head + + +def _discover(root: Path, max_file_bytes: int, generated_outputs: Iterable[str] = (), *, stable_exclusions: bool = False) -> tuple[list, list, list]: + """Read bounded files through directory descriptors; never follow symlinks.""" + if max_file_bytes < 1: + raise ValueError("max_file_bytes must be positive") + readable: list = [] + ledger: list = [] + diagnostics: list = [] + if not hasattr(os, "O_NOFOLLOW") or not hasattr(os, "O_DIRECTORY"): + raise OSError("safe native discovery requires no-follow directory descriptor support") + + def excluded(relative: str, reason: str, *, entry_kind: str = "file", digest: str = "hmmm", size: int | None = None) -> None: + item = {"file": relative, "entry_kind": entry_kind, "status": "excluded", "reason": reason, + "reader_ids": [], "content_sha256": digest} + if size is not None: + item["size"] = size + ledger.append(item) + + if stable_exclusions: + for name in sorted(_DEFAULT_SKIP): + excluded("**/" + name + "/**", "configured-subtree", entry_kind="subtree") + generated_outputs = set(generated_outputs) + for output in sorted(generated_outputs): + excluded(output, "generated-collection-output", entry_kind="output") + + def failed(relative: str, exc: Exception, entry_kind: str = "file") -> None: + ledger.append({"file": relative, "entry_kind": entry_kind, "status": "unreadable", "reader_ids": [], "content_sha256": "hmmm"}) + diagnostics.append({"code": "unreadable_path", "severity": "error", "status": "unreadable", + "message": type(exc).__name__, "source": {"file": relative}, "reader_id": None}) + + def visit(directory_fd: int, parent: str = "") -> None: + try: + names = sorted(os.listdir(directory_fd)) + except OSError as exc: + failed(parent or ".", exc, "subtree") + return + for name in names: + relative = f"{parent}/{name}" if parent else name + try: + if relative in generated_outputs: + continue + mode = os.stat(name, dir_fd=directory_fd, follow_symlinks=False).st_mode + if stat.S_ISLNK(mode): + excluded(relative, "symlink-not-followed", digest=_sha256(os.readlink(name, dir_fd=directory_fd))) + continue + if stat.S_ISDIR(mode): + if name in _DEFAULT_SKIP: + if not stable_exclusions: + excluded(relative, "configured-subtree", entry_kind="subtree") + else: + child = os.open(name, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=directory_fd) + try: + visit(child, relative) + finally: + os.close(child) + continue + if not stat.S_ISREG(mode): + excluded(relative, "not-regular-file") + continue + if name.endswith("_msdmd.ts"): + excluded(relative, "generated-collection-output") + continue + if name.startswith(".env") or name.endswith((".pem", ".key")): + excluded(relative, "secret-file-disclosure-boundary") + continue + fd = os.open(name, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=directory_fd) + with os.fdopen(fd, "rb") as handle: + info = os.fstat(handle.fileno()) + if not stat.S_ISREG(info.st_mode): + excluded(relative, "not-regular-file") + continue + if info.st_size > max_file_bytes: + excluded(relative, "size-limit", size=info.st_size) + continue + data = handle.read(max_file_bytes + 1) + if len(data) > max_file_bytes: + excluded(relative, "size-limit", size=len(data)) + continue + readable.append({"file": relative, "data": data, "content_sha256": _sha256(data), "size": len(data)}) + except OSError as exc: + failed(relative, exc) + try: + root_fd = os.open(root, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + except OSError as exc: + failed(".", exc, "subtree") + else: + try: + visit(root_fd) + finally: + os.close(root_fd) + return readable, ledger, diagnostics + + +def _reconcile_block_edges( + raw_edges: list[dict[str, Any]], + declarations: list[dict[str, Any]], + diagnostics: list[dict[str, Any]], +) -> list[dict[str, Any]]: + by_id: dict[str, list[str]] = defaultdict(list) + for declaration in declarations: + by_id[declaration["id"]].append(declaration["address"]) + edges: list[dict[str, Any]] = [] + for edge in raw_edges: + candidates = by_id.get(edge["to"], []) + if len(candidates) == 1: + edge["to"] = candidates[0] + edge["target_resolution"] = "resolved-unique-entry-id" + elif len(candidates) > 1: + diagnostics.append({ + "code": "ambiguous_edge_target", + "severity": "warning", + "status": "ambiguous", + "message": f"target {edge['to']!r} matches {len(candidates)} qualified declarations", + "source": {"address": edge["source_id"]}, + "reader_id": "msdmd-block", + "candidates": sorted(candidates), + }) + edge["target_resolution"] = "ambiguous" + else: + edge["target_resolution"] = "external-or-unresolved" + edges.append(edge) + return edges + + +def _duplicate_diagnostics(declarations: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: + groups: dict[tuple[str, str, str], list[dict[str, Any]]] = defaultdict(list) + for declaration in declarations: + groups[(declaration["file"], declaration["block"], declaration["id"])].append(declaration) + diagnostics: list[dict[str, Any]] = [] + conflicts: list[dict[str, Any]] = [] + for (file, block, entry_id), group in sorted(groups.items()): + if len(group) < 2: + continue + address = group[0]["address"] + diagnostics.append({ + "code": "duplicate_block_id", + "severity": "error", + "status": "invalid", + "message": f"{file} contains {len(group)} {block} entries with id {entry_id!r}", + "source": {"address": address, "file": file}, + "reader_id": "msdmd-block", + }) + conflicts.append({ + "kind": "identity-conflict", + "status": "unresolved", + "identity": address, + "witnesses": [item["source"] for item in group], + "reason": "duplicate entry id within one block type and owning file", + }) + return diagnostics, conflicts + + +def _native_identity_diagnostics(facts: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: + groups: dict[str, list[dict[str, Any]]] = defaultdict(list) + for fact in facts: + groups[fact["address"]].append(fact) + diagnostics: list[dict[str, Any]] = [] + conflicts: list[dict[str, Any]] = [] + for address, group in sorted(groups.items()): + if len(group) < 2: + continue + diagnostics.append({ + "code": "duplicate_native_fact_address", + "severity": "error", + "status": "invalid", + "message": f"collector generated {len(group)} native facts at one address", + "source": {"address": address, "file": group[0]["source"]["file"]}, + "reader_id": group[0]["extraction"]["reader_id"], + }) + conflicts.append({ + "kind": "collector-address-conflict", + "status": "unresolved", + "identity": address, + "witnesses": [item["source"] for item in group], + "reason": "multiple native facts received one generated collector address", + }) + return diagnostics, conflicts + + def collect( root: Path, repo: str, @@ -104,97 +419,402 @@ def collect( block_names: Iterable[str] = DEFAULT_BLOCK_NAMES, expected_blocks: Iterable[str] = (), source_commit: str | None = None, -) -> dict: - """Collect msdmd declarations and optional coverage gaps under ``root``.""" + max_file_bytes: int = DEFAULT_MAX_FILE_BYTES, + include_native: bool = True, + snapshot_identity: bool = False, + generated_outputs: Iterable[str] = (), + required_sources: Iterable[str] = (), + required_facts: Iterable[dict[str, str]] = (), +) -> dict[str, Any]: + """Collect native facts and supplemental blocks under ``root`` as schema 2.""" root = root.resolve() block_names = tuple(block_names) expected_blocks = tuple(expected_blocks) + revision, dirty, git_head = _git_identity(root, source_commit) + outputs = set(generated_outputs) | {repo.rsplit("/", 1)[-1] + "_msdmd.ts"} + readable, discovery, diagnostics = _discover(root, max_file_bytes, outputs, stable_exclusions=snapshot_identity) + required_sources = tuple(required_sources) + required_facts = tuple(required_facts) + for requirement in required_facts: + if set(requirement) != {"file", "convention", "kind"} or not all(isinstance(v, str) and v for v in requirement.values()): + raise ValueError("fact requirements must contain nonempty file, convention and kind strings") + codeowners_source = next((name for name in (".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS") if any(item["file"] == name for item in readable)), None) + if snapshot_identity: + if source_commit is not None: + raise ValueError("snapshot identity and an explicit commit cannot both be selected") + source_bytes = "\n".join(item["file"] + "\0" + item["content_sha256"] for item in sorted(readable, key=lambda x: x["file"])) + revision = "snapshot:" + _sha256(source_bytes) + dirty, git_head = "hmmm", None + if source_commit is not None and git_head is not None and source_commit != git_head: + diagnostics.append({ + "code": "source_revision_mismatch", + "severity": "error", + "status": "invalid", + "message": f"declared source revision {source_commit} does not match git HEAD {git_head}", + "source": {"file": ".", "declared_revision": source_commit, "git_head": git_head}, + "reader_id": None, + }) - declarations: list[dict] = [] - missing_by_file: dict[str, set[str]] = {} + declarations: list[dict[str, Any]] = [] + facts: list[dict[str, Any]] = [] + native_edges: list[dict[str, Any]] = [] + raw_block_edges: list[dict[str, Any]] = [] + missing_by_file: dict[str, set[str]] = defaultdict(set) + reader_counts: Counter[str] = Counter() + reader_fact_counts: Counter[str] = Counter() + block_files: dict[str, set[str]] = defaultdict(set) - for block in block_names: - annotated, _ = walk_tree(root, block) - for file, entries in annotated: + for item in readable: + relative = item["file"] + relative_path = Path(relative) + context = { + "repo": repo, + "revision": revision, + "file": relative, + "content_sha256": item["content_sha256"], + "codeowners_source": codeowners_source, + } + reader_ids, file_facts, file_edges, file_diagnostics = ( + read_native(relative_path, item["data"], context) + if include_native + else ([], [], [], []) + ) + file_statuses = {diagnostic.get("status") for diagnostic in file_diagnostics} + if "invalid" in file_statuses: + status = "invalid" + elif file_statuses & {"unsupported", "ambiguous", "dynamic-unresolved"} and file_facts: + status = "partial" + elif "dynamic-unresolved" in file_statuses: + status = "partial" + elif file_statuses & {"unsupported", "ambiguous"}: + status = "unsupported" + else: + status = "supported" if reader_ids else "unsupported" + discovery.append({ + "file": relative, + "entry_kind": "file", + "status": status, + "reader_ids": reader_ids, + "content_sha256": item["content_sha256"], + "size": item["size"], + }) + for reader_id in reader_ids: + reader_counts[reader_id] += 1 + for fact in file_facts: + reader_fact_counts[fact["extraction"]["reader_id"]] += 1 + facts.extend(file_facts) + native_edges.extend(file_edges) + diagnostics.extend(file_diagnostics) + + marker = marker_for(relative_path) + if marker is None: + continue + try: + text = _decode_block_source(relative_path, item["data"]) + except (SyntaxError, UnicodeDecodeError) as exc: + diagnostics.append({ + "code": "undecodable_block_source", + "severity": "error", + "status": "invalid", + "message": str(exc), + "source": {"file": relative, "content_sha256": item["content_sha256"]}, + "reader_id": "msdmd-block", + }) + continue + block_text = _block_source_text(relative_path, text) + if include_native and relative_path.suffix.lower() in {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts", ".rs", ".java", ".c", ".cpp", ".cc", ".cxx", ".hpp", ".hxx", ".h"}: + comments_available = any(f['kind'] == 'comment' and f['extraction']['reader_id'] in {'typescript-compiler', 'native-grammars'} for f in file_facts) + if not comments_available and file_statuses & {'unsupported', 'ambiguous', 'invalid'}: + candidates = [] + for candidate_block in block_names: + for entry in parse_text(text, candidate_block, marker): + candidate, _ = _redact_sensitive({'block': candidate_block, 'entry': entry}) + candidates.append(candidate) + if candidates: + diagnostics.append({'code': 'supplemental_comment_extraction_unavailable', 'severity': 'error', 'status': 'unsupported', + 'message': 'block-shaped candidates retained without certifying comment origin; install or select the native parser', + 'source': {'file': relative, 'content_sha256': item['content_sha256'], 'candidate_standing': 'unverified', 'candidate_blocks': candidates}, + 'reader_id': 'msdmd-block'}) + lines = [""] * len(text.split("\n")) + for fact in file_facts: + if fact["kind"] == "comment" and fact["extraction"]["reader_id"] in {"typescript-compiler", "native-grammars"}: + for offset, line in enumerate(fact["native"]["value"]["text"].split("\n")): + index = fact["source"]["location"]["start_line"] - 1 + offset + if index < len(lines): + lines[index] = line + block_text = "\n".join(lines) + for block in block_names: + entries = parse_text(block_text, block, marker) + if entries: + block_files[block].add(relative) + elif block in expected_blocks: + missing_by_file[relative].add(block) for entry in entries: if "id" not in entry: continue - declarations.append(_declaration(file.resolve(), root, block, entry)) + declaration = _block_declaration( + file=relative, + repo=repo, + revision=revision, + content_sha256=item["content_sha256"], + block=block, + entry=entry, + ) + declarations.append(declaration) + raw_block_edges.extend(_raw_block_edges(declaration)) - for block in expected_blocks: - _, missing_files = walk_tree(root, block) - for file in missing_files: - relative = file.resolve().relative_to(root).as_posix() - missing_by_file.setdefault(relative, set()).add(block) - - declarations.sort(key=lambda item: (item["file"], item["block"], item["id"])) + declarations.sort(key=lambda item: (item["file"], item["block"], item["id"], json.dumps(item["fields"], sort_keys=True))) + facts.sort(key=lambda item: item["address"]) + duplicate_diagnostics, conflicts = _duplicate_diagnostics(declarations) + diagnostics.extend(duplicate_diagnostics) + native_diagnostics, native_conflicts = _native_identity_diagnostics(facts) + diagnostics.extend(native_diagnostics) + conflicts.extend(native_conflicts) + block_edges = _reconcile_block_edges(raw_block_edges, declarations, diagnostics) + edges = native_edges + block_edges + edges.sort(key=lambda item: (item["from"], item["kind"], item["to"])) gaps = [ - {"file": file, "missing": sorted(missing)} + {"file": file, "missing": sorted(missing), "kind": "block-adoption"} for file, missing in sorted(missing_by_file.items()) ] - edges = [edge for declaration in declarations for edge in _edges_for(declaration)] - edges.sort(key=lambda item: (item["source_block"], item["source_id"], item["kind"], item["to"])) + discovery.sort(key=lambda item: item["file"]) + diagnostics.sort(key=lambda item: (str(item.get("source", {}).get("file", item.get("source", {}).get("address", ""))), item["code"], item["message"])) - collection = { + snapshot_entries = [ + f"{item['file']}\0{item.get('content_sha256', 'hmmm')}\0{item['status']}" + for item in discovery + ] + snapshot_sha256 = _sha256("\n".join(snapshot_entries)) + statuses = Counter(item["status"] for item in discovery if item.get("entry_kind", "file") == "file") + for pattern in required_sources: + matches = [item for item in discovery if item.get("entry_kind", "file") == "file" and fnmatch.fnmatchcase(item["file"], pattern)] + bad = [item for item in matches if item["status"] != "supported"] + if not matches or bad: + diagnostics.append({"code": "required_source_not_supported", "severity": "error", "status": "unsupported", + "message": "required source pattern has no matches or incomplete extraction: " + pattern, + "source": {"file": pattern, "matches": [{"file": i["file"], "status": i["status"]} for i in matches]}, "reader_id": None}) + requirements = [] + for requirement in required_facts: + matches = [item for item in discovery if item.get("entry_kind", "file") == "file" and fnmatch.fnmatchcase(item["file"], requirement["file"])] + results = [] + for item in matches: + witnesses = [fact["address"] for fact in facts if fact["source"]["file"] == item["file"] and fact["convention"]["namespace"] == requirement["convention"] and fact["kind"] == requirement["kind"]] + status = "provided" if witnesses and item["status"] == "supported" else "unresolved" if item["status"] != "supported" else "not-found-in-extracted-subset" + results.append({"file": item["file"], "status": status, "witnesses": witnesses}) + status = "provided" if results and all(r["status"] == "provided" for r in results) else "unresolved" + requirements.append({**requirement, "status": status, "sources": results}) + if status != "provided": + diagnostics.append({"code": "required_fact_unresolved", "severity": "error", "status": "unsupported", + "message": "required native fact is not supported by complete source extraction", + "source": dict(requirement), "reader_id": None}) + reader_runs = [] + for manifest in READER_MANIFESTS: + reader_id = manifest["reader_id"] + matched = reader_counts[reader_id] + reader_runs.append({ + "reader_id": reader_id, + "reader_version": manifest["version"], + "support": manifest["support"], + "status": "applied" if matched else "not-applicable", + "files_matched": matched, + "facts_emitted": reader_fact_counts[reader_id], + }) + + return { + "schema": SCHEMA_ID, + "schema_version": SCHEMA_VERSION, + "capabilities": [ + "native-facts", + "supplemental-msdmd-blocks", + "source-qualified-identities", + "duplicate-id-diagnostics", + "discovery-accounting", + ], "repo": repo, + "source": { + "repository": repo, + "revision": revision, + "git_head": git_head or "hmmm", + "dirty_worktree": dirty, + "snapshot_sha256": snapshot_sha256, + "snapshot_complete": not any(item["status"] == "unreadable" or (item["status"] == "excluded" and item.get("reason") not in {"configured-subtree", "generated-collection-output"}) for item in discovery), + "revision_kind": "content-snapshot" if snapshot_identity else "git-or-declared", + "scope": "configured in-scope files; excluded subtrees are reported without traversing", + "exclusion_accounting": "configured-patterns" if snapshot_identity else "observed-paths", + }, + "requirements": requirements, + "reader_manifests": list(READER_MANIFESTS), + "reader_runs": reader_runs, + "discovery": discovery, "declarations": declarations, + "facts": facts, "gaps": gaps, "edges": edges, + "conflicts": conflicts, + "diagnostics": diagnostics, + "coverage": { + "denominator": {"kind": "discovered-files", "count": sum(statuses.values())}, + "excluded_subtrees": sum(i.get("entry_kind") == "subtree" and i["status"] == "excluded" for i in discovery), + "required_sources": list(required_sources), + "supported_files": statuses["supported"], + "partial_files": statuses["partial"], + "unsupported_files": statuses["unsupported"], + "invalid_files": statuses["invalid"], + "excluded_files": statuses["excluded"], + "unreadable_files": statuses["unreadable"], + "native_facts": len(facts), + "supplemental_declarations": len(declarations), + "block_adoption": {block: len(block_files[block]) for block in block_names}, + "information_availability": "policy-evaluated" if required_facts else "not-evaluated-without-obligation-policy", + "verified_behavior": "not-evaluated", + }, } - if source_commit: - collection["source_commit"] = source_commit - return collection -def render_typescript(collection: dict, *, import_path: str) -> str: - """Render a collection as a `_msdmd.ts` module.""" - payload = json.dumps(collection, indent=2, sort_keys=True) - return ( - f'import {{ defineMsdmdCollection }} from "{import_path}";\n\n' - f"export default defineMsdmdCollection({payload});\n" +def collect_legacy( + root: Path, + repo: str, + *, + block_names: Iterable[str] = DEFAULT_BLOCK_NAMES, + expected_blocks: Iterable[str] = (), + source_commit: str | None = None, +) -> dict[str, Any]: + """Emit explicit schema-1 block-only compatibility output.""" + current = collect( + root, + repo, + block_names=block_names, + expected_blocks=expected_blocks, + source_commit=source_commit, + include_native=False, ) + declarations = [ + {"file": item["file"], "block": item["block"], "id": item["id"], "fields": item["fields"]} + for item in current["declarations"] + ] + legacy_by_address = {item["address"]: item["id"] for item in current["declarations"]} + edges = [] + for edge in current["edges"]: + if "source_block" not in edge: + continue + edges.append({ + "from": legacy_by_address.get(edge["from"], edge["from"]), + "to": legacy_by_address.get(edge["to"], edge["to"]), + "kind": edge["kind"], + "source_block": edge["source_block"], + "source_id": edge["source_entry_id"], + }) + result: dict[str, Any] = { + "schema_version": LEGACY_SCHEMA_VERSION, + "repo": repo, + "declarations": declarations, + "gaps": [{"file": item["file"], "missing": item["missing"]} for item in current["gaps"]], + "edges": edges, + } + if source_commit: + result["source_commit"] = source_commit + return result + + +def collection_errors(collection: dict[str, Any]) -> list[dict[str, Any]]: + """Return diagnostics that invalidate collection identity or syntax.""" + return [item for item in collection.get("diagnostics", []) if item.get("severity") == "error"] + + +def render_typescript(collection: dict[str, Any], *, import_path: str) -> str: + """Render a schema-1 or schema-2 collection as a TypeScript module.""" + helper = "defineMsdmdCollectionV2" if collection.get("schema_version") == SCHEMA_VERSION else "defineMsdmdCollection" + imports = helper + if helper == "defineMsdmdCollectionV2" and len(collection.get("facts", [])) > 64: + # Bound TypeScript contextual inference without casts or losing type checks. + imports += ", mergeMsdmdFactChunks" + parts = [] + for key, value in sorted(collection.items()): + if key == "facts": + chunks = [json.dumps(value[i:i + 64], indent=2, sort_keys=True, ensure_ascii=False, allow_nan=False) + for i in range(0, len(value), 64)] + rendered = "mergeMsdmdFactChunks(\n" + ",\n".join(chunks) + "\n)" + else: + rendered = json.dumps(value, indent=2, sort_keys=True, ensure_ascii=False, allow_nan=False) + parts.append(" " + json.dumps(key) + ": " + rendered.replace("\n", "\n ")) + payload = "{\n" + ",\n".join(parts) + "\n}" + else: + payload = json.dumps(collection, indent=2, sort_keys=True, ensure_ascii=False, allow_nan=False) + return f'import {{ {imports} }} from "{import_path}";\n\nexport default {helper}({payload});\n' def main() -> int: parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--root", type=Path, default=Path("."), help="repo root to scan") + parser.add_argument("--root", type=Path, default=Path("."), help="repository root to scan") parser.add_argument("--repo", required=True, help="repository slug for the collection") parser.add_argument("--out", type=Path, help="output .ts path; stdout when omitted") - parser.add_argument( - "--block", - action="append", - dest="blocks", - help="block name to collect; may be repeated; defaults to all known blocks", - ) - parser.add_argument( - "--expected-block", - action="append", - default=[], - help="block expected on every source file for gap reporting; may be repeated", - ) - parser.add_argument( - "--import-path", - default="./.agents/skills/msdmd/collection", - help="TypeScript import path for defineMsdmdCollection", - ) - parser.add_argument("--source-commit", help="source commit SHA to record") + parser.add_argument("--block", action="append", dest="blocks", help="supplemental block name to collect; may be repeated") + parser.add_argument("--expected-block", action="append", default=[], help="block expected on every supported line-comment file for adoption reporting") + parser.add_argument("--import-path", default="./.agents/skills/msdmd/collection", help="TypeScript import path for the schema helper") + parser.add_argument("--source-commit", help="source commit SHA to record; current git HEAD is detected when omitted") + parser.add_argument("--max-file-bytes", type=int, default=DEFAULT_MAX_FILE_BYTES, help="per-file read boundary") + parser.add_argument("--legacy-blocks-only", action="store_true", help="emit explicit schema-1 block-only compatibility output") + parser.add_argument("--snapshot-identity", action="store_true", help="bind generated output to source bytes rather than a circular output commit") + parser.add_argument("--require-source", action="append", default=[], help="glob that must have matched, fully extracted inputs; repeat as needed") + parser.add_argument("--require-fact", action="append", default=[], help="required fileglob::convention::kind, repeated as needed") + parser.add_argument("--json", action="store_true", help="emit raw collection JSON instead of TypeScript") + parser.add_argument("--check", action="store_true", help="compare --out without writing; nonzero on drift") + parser.add_argument("--strict", action="store_true", help="exit nonzero after rendering if invalid identity or syntax diagnostics exist") args = parser.parse_args() - collection = collect( - args.root, - args.repo, - block_names=args.blocks or DEFAULT_BLOCK_NAMES, - expected_blocks=args.expected_block, - source_commit=args.source_commit, - ) - rendered = render_typescript(collection, import_path=args.import_path) - if args.out: - args.out.write_text(rendered, encoding="utf-8") + required_facts = [] + for value in args.require_fact: + parts = value.split("::") + if len(parts) != 3 or not all(parts): + parser.error("--require-fact must be fileglob::convention::kind") + required_facts.append(dict(zip(("file", "convention", "kind"), parts))) + if args.legacy_blocks_only and (args.require_source or required_facts or args.snapshot_identity): + parser.error("legacy output cannot represent native coverage policies or snapshot identity") + if args.legacy_blocks_only: + collection = collect_legacy( + args.root, + args.repo, + block_names=args.blocks or DEFAULT_BLOCK_NAMES, + expected_blocks=args.expected_block, + source_commit=args.source_commit, + ) + else: + collection = collect( + args.root, + args.repo, + block_names=args.blocks or DEFAULT_BLOCK_NAMES, + expected_blocks=args.expected_block, + source_commit=args.source_commit, + max_file_bytes=args.max_file_bytes, + snapshot_identity=args.snapshot_identity, + generated_outputs=[args.out.resolve().relative_to(args.root.resolve()).as_posix()] if args.out and args.out.resolve().is_relative_to(args.root.resolve()) else [], + required_sources=args.require_source, + required_facts=required_facts, + ) + rendered = json.dumps(collection, indent=2, sort_keys=True, ensure_ascii=False, allow_nan=False) + "\n" if args.json else render_typescript(collection, import_path=args.import_path) + if args.check: + if not args.out: + parser.error("--check requires --out") + if not args.out.exists() or args.out.read_bytes() != rendered.encode("utf-8"): + print("collection drift: " + str(args.out)) + return 1 + elif args.out: + args.out.parent.mkdir(parents=True, exist_ok=True) + fd, temporary = tempfile.mkstemp(prefix=".msdmd-", dir=args.out.parent) + try: + with os.fdopen(fd, "wb") as handle: + handle.write(rendered.encode("utf-8")) + os.replace(temporary, args.out) + finally: + if os.path.exists(temporary): + os.unlink(temporary) else: print(rendered, end="") + if args.strict and not args.legacy_blocks_only and collection_errors(collection): + return 2 return 0 if __name__ == "__main__": raise SystemExit(main()) -# ratios: loc_comments=143:28 imports_exports=6:3 calls_definitions=35:6 +# ratios: loc_comments=706:54 imports_exports=17:5 calls_definitions=213:21 diff --git a/msdmd/collection.ts b/msdmd/collection.ts index 00195df..9d13533 100644 --- a/msdmd/collection.ts +++ b/msdmd/collection.ts @@ -1,12 +1,18 @@ // ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm /** - * Shared TypeScript shapes for repo-level msdmd collection points. + * Versioned TypeScript contracts for MSDMD collection points. * - * A consuming repo's `_msdmd.ts` file may import or copy these - * types, then export a `MsdmdCollection` generated from module-local msdmd - * blocks. This file is type-only: it does not parse source files or validate - * declarations. + * Usage guidance: + * - New native-capable generators call `defineMsdmdCollectionV2`. + * - Existing block-only files may keep `defineMsdmdCollection` while they + * explicitly remain schema 1. + * - Consumers must negotiate `schema_version`; schema 1 cannot represent + * native facts and must never receive a silent lossy projection. */ + +export type JsonPrimitive = string | number | boolean | null; +export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue }; + export type MsdmdBlockName = | "DOCS" | "CAPABILITIES" @@ -22,54 +28,229 @@ export type MsdmdBlockName = export type MsdmdFieldMap = Record; -export interface MsdmdDeclaration { - /** Repository-relative source file that owns the declaration. */ +/** Schema-1 block declaration retained only for explicit legacy consumers. */ +export interface MsdmdDeclarationV1 { file: string; - /** msdmd application block name, such as CONTRACTS, CHECKS, or DOCS. */ block: MsdmdBlockName; - /** Stable entry id declared inside the block. */ id: string; - /** Flat parsed fields, excluding id unless a generator intentionally repeats it. */ fields: MsdmdFieldMap; } -export interface MsdmdGap { - /** Repository-relative source file with missing expected block coverage. */ +export interface MsdmdGapV1 { file: string; - /** Block types expected by local policy but absent from this file. */ - missing: MsdmdBlockName[]; - /** Optional explanation from the collector or policy layer. */ + missing: string[]; reason?: string; } -export interface MsdmdEdge { - /** Source declaration id or file path. */ +export interface MsdmdEdgeV1 { from: string; - /** Target declaration id, capability id, owner, route, file, or external system. */ to: string; - /** Relationship kind: requires, exposes, owns, covers, calls, claims_proves, risk, etc. */ kind: string; - /** Block that produced this edge. */ source_block: MsdmdBlockName; - /** Entry id that produced this edge. */ source_id: string; } -export interface MsdmdCollection { - /** Repository slug, for example a0 or skill-lib. */ +/** Block-only schema. It cannot represent native facts. */ +export interface MsdmdCollectionV1 { + schema_version?: "1.0.0"; repo: string; - /** Parsed module-local msdmd entries. */ - declarations: MsdmdDeclaration[]; - /** Visible coverage gaps emitted by collectors or local policy. */ - gaps: MsdmdGap[]; - /** Optional normalized relationship graph for visualizers. */ - edges?: MsdmdEdge[]; - /** Optional collector metadata. */ + declarations: MsdmdDeclarationV1[]; + gaps: MsdmdGapV1[]; + edges?: MsdmdEdgeV1[]; generated_at?: string; source_commit?: string; } -export function defineMsdmdCollection(collection: MsdmdCollection): MsdmdCollection { +/** Explicit names retained for schema-1 source compatibility; never used for native facts. */ +export type MsdmdDeclaration = MsdmdDeclarationV1; +export type MsdmdGap = MsdmdGapV1; +export type MsdmdEdge = MsdmdEdgeV1; +export type MsdmdCollection = MsdmdCollectionV1; + +export type MsdmdSourceLocation = + | { pointer: string } + | { start_line: number; end_line: number; span?: JsonValue; start_byte?: number; end_byte?: number }; + +export interface MsdmdSourceReference { + repository: string; + revision: string; + file: string; + content_sha256: string; + location: MsdmdSourceLocation; +} + +export interface MsdmdDeclarationV2 { + address: string; + origin: "msdmd-block"; + standing: "declared"; + source: MsdmdSourceReference; + file: string; + block: MsdmdBlockName; + id: string; + fields: MsdmdFieldMap; +} + +export interface MsdmdNativeFact { + address: string; + origin: "native"; + kind: string; + source: MsdmdSourceReference; + subject: { + address: string; + scope: string; + identity: string; + }; + convention: { + namespace: string; + version: string; + dialect: string; + }; + native: { + id: string | null; + value: JsonValue; + }; + standing: "declared" | "syntactically-observed" | "derived" | "reported-evidence"; + extraction: { + reader_id: string; + reader_version: string; + support: "implemented-and-tested" | "partial" | "specified-only" | "unsupported"; + configuration_sha256: string; + implementation_sha256?: string; + }; + projection?: { + mapping_version: string; + canonical_field?: string; + relation?: string; + loss: string; + }; +} + +export interface MsdmdReaderManifest { + reader_id: string; + version: string; + entry_point: string; + dependencies: string[]; + convention: string; + specification: string; + supported_versions: string[]; + feature_subset: string[]; + detection: string[]; + scope_attachment: string; + unknown_field_policy: string; + execution_policy: string; + support: "implemented-and-tested" | "partial" | "specified-only" | "unsupported"; + known_limitations?: string[]; +} + +export interface MsdmdReaderRun { + reader_id: string; + reader_version: string; + support: MsdmdReaderManifest["support"]; + status: "applied" | "not-applicable"; + files_matched: number; + facts_emitted: number; +} + +export interface MsdmdDiscoveryEntry { + file: string; + status: "supported" | "partial" | "unsupported" | "invalid" | "excluded" | "unreadable"; + reader_ids: string[]; + content_sha256: string; + entry_kind?: "file" | "subtree" | "output"; + size?: number; + reason?: string; +} + +export interface MsdmdEdgeV2 { + from: string; + to: string; + kind: string; + standing: "declared" | "syntactically-observed" | "derived" | "reported-evidence"; + target_resolution: "resolved-unique-entry-id" | "external-or-unresolved" | "ambiguous"; + source_block?: MsdmdBlockName; + source_id?: string; + source_entry_id?: string; +} + +export interface MsdmdDiagnostic { + code: string; + severity: "error" | "warning" | "info"; + status: string; + message: string; + source: JsonValue; + reader_id: string | null; + candidates?: string[]; +} + +export interface MsdmdConflict { + kind: string; + status: "unresolved" | "resolved"; + identity: string; + witnesses: MsdmdSourceReference[]; + reason: string; +} + +export interface MsdmdGapV2 { + file: string; + missing: MsdmdBlockName[]; + kind: "block-adoption"; +} + +export interface MsdmdCollectionV2 { + schema: "the-interdependency.msdmd-collection"; + schema_version: "2.0.0"; + capabilities: string[]; + repo: string; + source: { + repository: string; + revision: string; + git_head: string; + dirty_worktree: boolean | "hmmm"; + snapshot_sha256: string; + snapshot_complete: boolean; + revision_kind?: "content-snapshot" | "git-or-declared"; + exclusion_accounting?: "configured-patterns" | "observed-paths"; + scope?: string; + }; + requirements?: JsonValue[]; + reader_manifests: MsdmdReaderManifest[]; + reader_runs: MsdmdReaderRun[]; + discovery: MsdmdDiscoveryEntry[]; + declarations: MsdmdDeclarationV2[]; + facts: MsdmdNativeFact[]; + gaps: MsdmdGapV2[]; + edges: MsdmdEdgeV2[]; + conflicts: MsdmdConflict[]; + diagnostics: MsdmdDiagnostic[]; + coverage: { + denominator: { kind: "discovered-files"; count: number }; + excluded_subtrees?: number; + required_sources?: string[]; + supported_files: number; + partial_files: number; + unsupported_files: number; + invalid_files: number; + excluded_files: number; + unreadable_files: number; + native_facts: number; + supplemental_declarations: number; + block_adoption: Record; + information_availability: "not-evaluated-without-obligation-policy" | "policy-evaluated"; + verified_behavior: "not-evaluated"; + }; +} + +/** Explicit compatibility helper for block-only schema-1 collection points. */ +export function defineMsdmdCollection(collection: MsdmdCollectionV1): MsdmdCollectionV1 { return collection; } + +/** Native-capable schema-2 helper. Consumers must opt into this exact version. */ +export function defineMsdmdCollectionV2(collection: MsdmdCollectionV2): MsdmdCollectionV2 { + return collection; +} +/** Keep large generated literals type-checkable without any/unknown casts. */ +export function mergeMsdmdFactChunks(...chunks: MsdmdNativeFact[][]): MsdmdNativeFact[] { + return chunks.flat(); +} // ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm diff --git a/msdmd/formats.py b/msdmd/formats.py new file mode 100644 index 0000000..eed8a5b --- /dev/null +++ b/msdmd/formats.py @@ -0,0 +1,189 @@ +# ratios: loc_comments=151:14 imports_exports=9:5 calls_definitions=78:11 +"""Bounded, non-executing parsers shared by the native metadata adapters. + +Usage: parse_json(bytes), parse_yaml(bytes), parse_xml(bytes). No includes, +constructors, network references or target code are executed. YAML uses PyYAML's +syntax parser with explicit YAML 1.2 core scalar resolution and typed scalar keys. +Repeated keys, cyclic aliases, custom tags, merge keys and excessive expansion +are errors, never silently flattened. XML supports UTF-8, without DTD/entities. +""" +from __future__ import annotations + +import json +from decimal import Decimal +import math +import re +import xml.etree.ElementTree as ET +from typing import Any +from urllib.parse import urlsplit + +def is_json_schema_uri(value: Any) -> bool: + """Recognize the exact JSON Schema URI authority without fetching it. + + Usage: pass a native $schema value, without coercing its type. This + recognizes the owning namespace, not a supported draft or trusted URL. + Userinfo, explicit ports, lookalike hosts and control characters are + outside this recognition subset and remain unclassified source data. + """ + if not isinstance(value, str) or any(ord(char) <= 32 or ord(char) == 127 for char in value): + return False + try: + uri = urlsplit(value) + except ValueError: + return False + return uri.scheme in {'http', 'https'} and uri.netloc.lower() == 'json-schema.org' + + +MAX_NODES = 100_000 +MAX_DEPTH = 128 + + +def check_tree(value: Any, depth: int = 0, budget: list[int] | None = None) -> Any: + budget = [MAX_NODES] if budget is None else budget + budget[0] -= 1 + if depth > MAX_DEPTH or budget[0] < 0: + raise ValueError('structured input exceeds node/depth limit') + if isinstance(value, dict): + for item in value.values(): + check_tree(item, depth + 1, budget) + elif isinstance(value, list): + for item in value: + check_tree(item, depth + 1, budget) + return value + + +def parse_json(data: bytes) -> Any: + def pairs(items: list[tuple[str, Any]]) -> dict[str, Any]: + result: dict[str, Any] = {} + for key, value in items: + if key in result: + raise ValueError('duplicate JSON object key') + result[key] = value + return result + + def constant(value: str) -> Any: + raise ValueError('non-finite JSON number') + + def integer(value: str) -> Any: + result = int(value) + if abs(result) > 2 ** 53 - 1 or value == '-0': + return {'$type': 'json-number', 'lexeme': value} + return result + + def number(value: str) -> Any: + result = float(value) + if not math.isfinite(result): + raise ValueError('JSON number exceeds finite numeric representation') + original = Decimal(value) + if original != Decimal.from_float(result) or (result == 0 and original.is_signed()): + return {'$type': 'json-number', 'lexeme': value} + return result + + return check_tree(json.loads(data, object_pairs_hook=pairs, parse_constant=constant, parse_int=integer, parse_float=number)) + + +def parse_yaml(data: bytes) -> Any: + import yaml # Optional reader dependency; missing installation is diagnostic. + + class CoreLoader(yaml.BaseLoader): + yaml_implicit_resolvers: dict = {} + CoreLoader.add_implicit_resolver('tag:yaml.org,2002:null', re.compile(r'^(?:~|null|Null|NULL|)$'), ['~', 'n', 'N', '']) + CoreLoader.add_implicit_resolver('tag:yaml.org,2002:bool', re.compile(r'^(?:true|True|TRUE|false|False|FALSE)$'), list('tTfF')) + CoreLoader.add_implicit_resolver('tag:yaml.org,2002:int', re.compile(r'^(?:[-+]?[0-9]+|0o[0-7]+|0x[0-9a-fA-F]+)$'), list('-+0123456789')) + CoreLoader.add_implicit_resolver('tag:yaml.org,2002:float', re.compile(r'^[-+]?(?:(?:[0-9]+\.[0-9]*|\.[0-9]+|[0-9]+[eE][-+]?[0-9]+)(?:[eE][-+]?[0-9]+)?|\.(?:inf|Inf|INF|nan|NaN|NAN))$'), list('-+.0123456789')) + node = yaml.compose(data.decode('utf-8-sig'), Loader=CoreLoader) + active: set[int] = set() + budget = [MAX_NODES] + + def scalar(text: str, tag: str) -> Any: + if tag not in {'tag:yaml.org,2002:str', 'tag:yaml.org,2002:bool', + 'tag:yaml.org,2002:null', 'tag:yaml.org,2002:int', + 'tag:yaml.org,2002:float'}: + raise ValueError('unsupported YAML tag') + if tag == 'tag:yaml.org,2002:str': + return text + if tag.endswith(':null') and text in {'', '~', 'null', 'Null', 'NULL'}: + return None + if tag.endswith(':bool') and text in {'true', 'True', 'TRUE', 'false', 'False', 'FALSE'}: + return text.lower() == 'true' + if tag.endswith(':int'): + if re.fullmatch(r'[-+]?[0-9]+', text): + return int(text, 10) + if re.fullmatch(r'0o[0-7]+', text): + return int(text[2:], 8) + if re.fullmatch(r'0x[0-9a-fA-F]+', text): + return int(text[2:], 16) + if tag.endswith(':float'): + if text.lower().lstrip('+-') in {'.inf', '.nan'}: + return {'$type': 'yaml-nonfinite', 'value': text} + if re.fullmatch(r'[-+]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][-+]?[0-9]+)?', text): + value = float(text) + if not math.isfinite(value): + raise ValueError('YAML number exceeds finite numeric representation') + return value + raise ValueError('invalid explicitly tagged YAML scalar') + + def visit(item: Any, depth: int = 0) -> Any: + if item is None: + return None + budget[0] -= 1 + if depth > MAX_DEPTH or budget[0] < 0: + raise ValueError('YAML alias expansion exceeds node/depth limit') + if id(item) in active: + raise ValueError('cyclic YAML alias') + active.add(id(item)) + try: + if isinstance(item, yaml.ScalarNode): + if item.tag == 'tag:yaml.org,2002:str' and item.style is not None: + return item.value + return scalar(item.value, item.tag) + if isinstance(item, yaml.SequenceNode): + if item.tag != 'tag:yaml.org,2002:seq': + raise ValueError('unsupported YAML sequence tag') + return [visit(child, depth + 1) for child in item.value] + if isinstance(item, yaml.MappingNode): + if item.tag != 'tag:yaml.org,2002:map': + raise ValueError('unsupported YAML mapping tag') + entries: list[dict] = [] + seen: set[str] = set() + string_keys = True + for key, value in item.value: + if not isinstance(key, yaml.ScalarNode): + raise ValueError('non-scalar YAML key is outside metadata mapping subset') + name = visit(key, depth + 1) + if name == '<<': + raise ValueError('YAML merge keys require a declared merge dialect') + signature = key.tag + ':' + json.dumps(name, sort_keys=True) + if signature in seen: + raise ValueError('duplicate YAML mapping key') + seen.add(signature) + string_keys = string_keys and isinstance(name, str) + entries.append({'key': name, 'tag': key.tag, 'value': visit(value, depth + 1)}) + if string_keys: + return {entry['key']: entry['value'] for entry in entries} + # JSON object keys cannot encode typed YAML keys without loss. + return {'$type': 'yaml-mapping', 'entries': entries} + raise ValueError('unknown YAML node') + finally: + active.remove(id(item)) + + return visit(node) + + +def parse_xml(data: bytes) -> ET.Element: + text = data.decode('utf-8-sig') + if '\x00' in text or re.search(r' MAX_DEPTH or count > MAX_NODES: + raise ValueError('XML exceeds node/depth limit') + stack.extend((child, depth + 1) for child in node) + return root +# ratios: loc_comments=151:14 imports_exports=9:5 calls_definitions=78:11 diff --git a/msdmd/grammar_code.py b/msdmd/grammar_code.py new file mode 100644 index 0000000..b2ba5be --- /dev/null +++ b/msdmd/grammar_code.py @@ -0,0 +1,136 @@ +# ratios: loc_comments=116:9 imports_exports=8:1 calls_definitions=41:4 +"""Source metadata from pinned Rust, Java, C and C++ grammars. + +Usage: read_grammar(path, supplied_bytes, context) through msdmd.collect. +No build, macro expansion, annotation processing or target import occurs. .h +requires explicit language selection and is reported ambiguous. Documentation +retains raw comments and repeated tags; it does not run rustdoc or Doxygen. +""" +from __future__ import annotations + +import hashlib +import importlib +import re +from pathlib import Path +from typing import Any + +GRAMMARS = {'.rs': ('rust', '0.24.2'), '.java': ('java', '0.23.5'), + '.c': ('c', '0.24.2'), '.cpp': ('cpp', '0.23.4'), + '.cc': ('cpp', '0.23.4'), '.cxx': ('cpp', '0.23.4'), + '.hpp': ('cpp', '0.23.4'), '.hxx': ('cpp', '0.23.4')} +DECLARATIONS = {'function_item', 'function_signature_item', 'struct_item', + 'enum_item', 'trait_item', 'type_item', 'mod_item', 'const_item', 'static_item', + 'class_declaration', 'interface_declaration', 'enum_declaration', 'record_declaration', + 'method_declaration', 'constructor_declaration', 'annotation_type_declaration', + 'function_definition', 'class_specifier', 'struct_specifier', 'enum_specifier', + 'namespace_definition', 'declaration'} + + +def read_grammar(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]: + from tree_sitter import Language, Parser + from msdmd.readers import _fact, _diagnostic + rid = 'native-grammars' + if path.suffix == '.h': + return [], [], [_diagnostic(context, reader_id=rid, code='ambiguous_header_language', + message='.h can be C or C++; supply an unambiguous .c/.hpp source representation', status='ambiguous')] + language, version = GRAMMARS[path.suffix.lower()] + # Only hard-coded installed grammar modules are loaded, never target modules. + grammar = importlib.import_module('tree_sitter_' + language) + tree = Parser(Language(grammar.language())).parse(data) + namespace = {'rust': 'rustdoc', 'java': 'javadoc', 'c': 'doxygen', 'cpp': 'doxygen'}[language] + context = dict(context, convention_version=f'{language}-grammar@{version}', dialect=language) + facts: list = [] + diagnostics: list = [] + nodes: list = [] + stack = [tree.root_node] + while stack: + node = stack.pop() + nodes.append(node) + stack.extend(reversed(node.named_children)) + if tree.root_node.has_error: + diagnostics.append(_diagnostic(context, reader_id=rid, code='source_grammar_error', + message='source contains grammar errors; recovered facts are partial', status='invalid', severity='error')) + declarations: list[tuple[Any, str]] = [] + counts: dict[str, int] = {} + + def text(node: Any) -> str: + return data[node.start_byte:node.end_byte].decode('utf-8') + + def name_of(node: Any) -> str | None: + name = node.child_by_field_name('name') + declarator = node.child_by_field_name('declarator') + while name is None and declarator is not None: + if declarator.type in {'identifier', 'field_identifier', 'qualified_identifier'}: + name = declarator + break + declarator = declarator.child_by_field_name('declarator') + return text(name) if name is not None else None + + def emit(node: Any, kind: str, identity: str, value: Any, *, scope: str = 'symbol', convention: str | None = None) -> dict: + key = kind + ':' + identity + ordinal = counts.get(key, 0) + counts[key] = ordinal + 1 + fact = _fact(context, reader_id=rid, kind=kind, scope=scope, identity=identity, + convention=convention or language + '.source-metadata', + location={'start_line': node.start_point.row + 1, 'end_line': node.end_point.row + 1, + 'start_byte': node.start_byte, 'end_byte': node.end_byte}, value=value) + fact['address'] = fact['subject']['address'] + '/fact/' + kind + '/' + str(ordinal) + facts.append(fact) + return fact + + for node in nodes: + if node.type in DECLARATIONS and (name := name_of(node)): + parents = [(parent, identity) for parent, identity in declarations + if parent.start_byte <= node.start_byte and parent.end_byte >= node.end_byte] + parent = parents[-1][1] if parents else '' + # Rust impl blocks have no named declaration; retain their type context. + ancestor = node.parent + impl = None + while ancestor is not None and ancestor.type not in DECLARATIONS: + if ancestor.type == 'impl_item': + impl = ancestor.child_by_field_name('type') + break + ancestor = ancestor.parent + if impl is not None: + parent = '.'.join(filter(None, (parent, text(impl)))) + identity = '.'.join(filter(None, (parent, name))) + body = node.child_by_field_name('body') + signature = data[node.start_byte:body.start_byte if body else node.end_byte].decode('utf-8').strip() + declarations.append((node, identity)) + emit(node, 'symbol-declaration', identity, {'name': name, 'qualified_name': identity, + 'syntax_kind': node.type, 'signature': signature, 'condition_resolution': 'not-evaluated'}) + if node.type in {'use_declaration', 'import_declaration', 'package_declaration', 'preproc_include', 'attribute_item', 'inner_attribute_item'}: + emit(node, 'source-declaration', context['file'], {'syntax_kind': node.type, 'text': text(node)}, scope='module') + if node.type in {'macro_invocation', 'preproc_if', 'preproc_ifdef'}: + diagnostics.append(_diagnostic(context, reader_id=rid, code='unresolved_compile_context', + message='macro/preprocessor context is preserved but not evaluated', status='dynamic-unresolved')) + for node in nodes: + if node.type not in {'line_comment', 'block_comment', 'comment'}: + continue + raw = text(node) + enclosing = [(owner, ident) for owner, ident in declarations + if owner.start_byte <= node.start_byte and owner.end_byte >= node.end_byte] + identity = enclosing[-1][1] if enclosing else context['file'] + scope = 'symbol' if enclosing else 'module' + doc = raw.startswith(('/**', '/*!', '///', '//!')) + attachment = 'enclosing' if enclosing else 'module' + if doc and not raw.startswith(('//!', '/*!')): + following = [(owner, ident) for owner, ident in declarations if owner.start_byte >= node.end_byte] + if following: + owner, candidate = following[0] + between = data[node.end_byte:owner.start_byte].decode('utf-8') + # Only comments/attributes can bridge leading documentation. + scrubbed = re.sub(r'/\*.*?\*/|//[^\n]*|#\[[^\]]*\]', '', between, flags=re.S) + if not scrubbed.strip(): + identity, scope, attachment = candidate, 'symbol', 'leading-documentation' + emit(node, 'comment', identity, {'text': raw, 'attachment': attachment}, scope=scope) + if doc: + tags = [{'name': match[1], 'text': match[2].strip()} + for match in re.finditer(r'(?:^|\n)\s*(?:\*|///|//!)?\s*[@\\]([A-Za-z]+)\s*([^\n]*)', raw.removeprefix('/**').removesuffix('*/'))] + emit(node, 'documentation-comment', identity, {'text': raw, 'tags': tags, + 'attachment': attachment, 'expansion': 'not-performed'}, scope=scope, convention=namespace) + for match in re.finditer(r'SPDX-(License-Identifier|FileCopyrightText):\s*([^\n*]+)', raw): + emit(node, 'license-declaration', context['file'], {'tag': 'SPDX-' + match[1], 'value': match[2].strip()}, + scope='module', convention='spdx.source-header') + return facts, [], diagnostics +# ratios: loc_comments=116:9 imports_exports=8:1 calls_definitions=41:4 diff --git a/msdmd/module_projection.py b/msdmd/module_projection.py index 40b44c4..7c84891 100644 --- a/msdmd/module_projection.py +++ b/msdmd/module_projection.py @@ -1,4 +1,4 @@ -# ratios: loc_comments=904:124 imports_exports=14:9 calls_definitions=256:53 +# ratios: loc_comments=910:128 imports_exports=14:10 calls_definitions=259:54 # === MODULE_BUILD === # id: msdmd_python_module_projection # module_name: module_projection @@ -810,7 +810,20 @@ def project_python_module( except ValueError as exc: raise ValueError(f"source escapes root: {path}") from exc - source = resolved.read_bytes() + return project_python_bytes(resolved.read_bytes(), source_path=relative, repo=repo, revision=revision) + + +def project_python_bytes( + source: bytes, *, source_path: str, repo: str, revision: str | None = None, +) -> list[dict]: + """Project an already-bounded immutable buffer; never reopen the inspected file. + + The path is provenance only. Both the standalone file runner and unified + collector call this same syntax/attachment implementation. + """ + relative = Path(source_path).as_posix() + if Path(relative).is_absolute() or ".." in Path(relative).parts: + raise ValueError("source_path must be repository-relative") source_sha256 = _sha256(source) reader_sha256 = _reader_sha256() schema_sha256 = _schema_sha256() @@ -1164,4 +1177,4 @@ def main(argv: list[str] | None = None) -> int: if __name__ == "__main__": raise SystemExit(main()) -# ratios: loc_comments=904:124 imports_exports=14:9 calls_definitions=256:53 +# ratios: loc_comments=910:128 imports_exports=14:10 calls_definitions=259:54 diff --git a/msdmd/native_code.py b/msdmd/native_code.py new file mode 100644 index 0000000..ba276be --- /dev/null +++ b/msdmd/native_code.py @@ -0,0 +1,220 @@ +# ratios: loc_comments=195:14 imports_exports=15:3 calls_definitions=83:3 +"""Syntax-aware code readers for the unified collection. + +Usage: registry calls read_python/read_typescript with bounded bytes and context. +Python delegates symbol/comment attachment to module_projection. The TypeScript +compiler is a library worker, not the inspected program. Neither reader resolves +imports, loads target configuration, or establishes runtime behavior. +""" +from __future__ import annotations + +import ast +import hashlib +import json +import os +import re +import subprocess +import sys +from pathlib import Path +from typing import Any + +from msdmd.module_projection import project_python_bytes, _byte_line_reader +import tokenize + + +def read_python(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]: + from msdmd.readers import _fact, _diagnostic, _subject_address, _edge + context = dict(context, convention_version=f'Python {sys.version_info.major}.{sys.version_info.minor}', dialect='python') + rid = 'python-ast' + records = project_python_bytes(data, source_path=context['file'], repo=context['repo'], revision=context['revision']) + header = records[0] + facts: list = [] + edges: list = [] + diagnostics: list = [] + symbols = {r['id']: r for r in records if r['record_type'] == 'symbol'} + identities = {key: value['qualified_name'] for key, value in symbols.items()} + # Only duplicate qualified names need the attachment reader's signature suffix. + counts: dict[str, int] = {} + for name in identities.values(): + counts[name] = counts.get(name, 0) + 1 + identities = {key: name if counts[name] == 1 else key for key, name in identities.items()} + identities[header['module_id']] = context['file'] + metadata_counts: dict[tuple[str, str], int] = {} + + def location(record: dict) -> dict: + span = record['source_span'] + return {'start_line': span['start']['line'], 'end_line': span['end']['line']} + + for record in records[1:]: + if record['record_type'] == 'diagnostic': + diagnostics.append(_diagnostic(context, reader_id=rid, code=record['code'], + message=record['message'], status='invalid', severity='error')) + continue + if record['record_type'] == 'symbol': + identity = identities[record['id']] + kind = 'class-declaration' if record['kind'] == 'class' else 'callable-declaration' + fact = _fact(context, reader_id=rid, kind=kind, scope='symbol', identity=identity, + location=location(record), native_id=record['qualified_name'], value={ + 'name': record['qualified_name'].split('.')[-1], 'qualified_name': record['qualified_name'], + 'kind': record['kind'], 'signature': record['signature'], 'decorators': record['decorators'], + 'attachment_identity': record['id'], 'parent_identity': record['parent']}, + projection={'mapping_version': 'python-surfaces@2', 'canonical_field': 'declared_surface', 'loss': 'behavior not inferred'}) + # Stable semantic pointer; exact byte/line span is provenance, not identity. + fact['address'] = fact['subject']['address'] + '/fact/declaration' + fact['source']['location']['span'] = record['source_span'] + facts.append(fact) + continue + if record['record_type'] != 'metadata': + continue + identity = identities.get(record['subject'], record['subject']) + scope = 'module' if record['subject'] == header['module_id'] else 'symbol' + kind = 'documentation' if record['metadata_kind'] == 'documentation' else 'comment' + value = {'text': record['text'], 'attachment': record['attachment'], + 'attachment_identity': record['subject'], 'metadata_kind': record['metadata_kind']} + if kind == 'documentation': + try: + import docstring_parser + parsed = docstring_parser.parse(record['text']) + value['format'] = parsed.style.name.lower() + value['fields'] = [dict(vars(field)) for field in parsed.meta] + value['summary'] = parsed.short_description + value['description'] = parsed.long_description + except ImportError: + diagnostics.append(_diagnostic(context, reader_id=rid, code='missing_docstring_parser', + message='install msdmd/requirements.txt to extract structured docstring fields', status='unsupported')) + except Exception as exc: + # A parser rejection must not discard the source-owned docstring. + diagnostics.append(_diagnostic(context, reader_id=rid, code='docstring_parse_error', + message=type(exc).__name__, status='unsupported')) + key = (record['subject'], kind) + ordinal = metadata_counts.get(key, 0); metadata_counts[key] = ordinal + 1 + fact = _fact(context, reader_id=rid, kind=kind, scope=scope, identity=identity, + location=location(record), value=value, + convention='python.pep257' if kind == 'documentation' else 'python.line-comment', standing='declared') + fact['address'] = fact['subject']['address'] + f'/fact/{kind}/{ordinal}' + fact['source']['location']['span'] = record['source_span'] + facts.append(fact) + if kind == 'comment': + for line_ordinal, line in enumerate(record['text'].splitlines()): + for tag in ('SPDX-License-Identifier', 'SPDX-FileCopyrightText'): + if tag + ':' in line: + facts.append(_fact(context, reader_id=rid, kind='license-declaration', scope=scope, + identity=identity, location=location(record), value={'tag': tag, 'value': line.split(tag + ':', 1)[1].strip()}, + native_id=f'{tag}:{ordinal}:{line_ordinal}', convention='spdx.file-header', standing='declared')) + if header['status'] == 'invalid': + return facts, edges, diagnostics + encoding = tokenize.detect_encoding(_byte_line_reader(data))[0] + tree = ast.parse(data.decode(encoding), type_comments=True) + import_ordinals: dict[str, int] = {} + for node in ast.walk(tree): + if not isinstance(node, (ast.Import, ast.ImportFrom)): + continue + owners = [r for r in symbols.values() if r['source_span']['start']['line'] <= node.lineno <= r['source_span']['end']['line']] + owner = min(owners, key=lambda r: r['source_span']['end']['line'] - r['source_span']['start']['line']) if owners else None + identity = identities[owner['id']] if owner else context['file'] + scope = 'symbol' if owner else 'module' + for alias in node.names: + module = alias.name if isinstance(node, ast.Import) else '.' * node.level + (node.module or '') + item = {'kind': 'import' if isinstance(node, ast.Import) else 'from_import', + 'module': module, 'name': alias.name, 'alias': alias.asname, + 'level': getattr(node, 'level', 0)} + ordinal = import_ordinals.get(identity, 0); import_ordinals[identity] = ordinal + 1 + fact = _fact(context, reader_id=rid, kind='dependency', scope=scope, identity=identity, + location={'start_line': node.lineno, 'end_line': node.end_lineno}, value=item, + native_id=f'{module}:{alias.name}:{ordinal}', projection={ + 'mapping_version': 'python-imports@2', 'relation': 'imports', 'loss': 'conditions retained in source; resolution not executed'}) + fact['address'] = fact['subject']['address'] + f'/fact/import/{ordinal}' + facts.append(fact) + edges.append(_edge(fact['subject']['address'], 'python-module:' + module, 'imports')) + # A literal initializer is not a complete export set after another write, + # mutation, conditional assignment, or escape through an alias/call. + # Only one simple module-level literal assignment with no subsequent uses + # earns static standing. Other syntax remains visible without execution. + assignments = [] + allowed_names: set[int] = set() + for node in tree.body: + targets = node.targets if isinstance(node, ast.Assign) else [node.target] if isinstance(node, ast.AnnAssign) else [] + if len(targets) == 1 and isinstance(targets[0], ast.Name) and targets[0].id == '__all__': + assignments.append(node) + allowed_names.add(id(targets[0])) + export_uses = [node for node in ast.walk(tree) if isinstance(node, ast.Name) and node.id == '__all__'] + unresolved = len(assignments) != 1 or any(id(node) not in allowed_names for node in export_uses) + if assignments: + node = assignments[-1] + value = node.value + literal = isinstance(value, (ast.List, ast.Tuple)) and all( + isinstance(item, ast.Constant) and isinstance(item.value, str) for item in value.elts) + unresolved = unresolved or not literal + names = [item.value for item in value.elts] if literal else None + facts.append(_fact(context, reader_id=rid, kind='exports', scope='module', identity=context['file'], + location={'start_line': node.lineno, 'end_line': node.end_lineno}, native_id='__all__', + value={'names': names if not unresolved else None, + 'declared_names': names, + 'resolution': 'dynamic-unresolved' if unresolved else 'static'})) + if export_uses and unresolved: + diagnostics.append(_diagnostic(context, reader_id=rid, code='dynamic_python_exports', + message='__all__ has a nonliteral, repeated, conditional, mutated or escaped declaration; final exports not inferred', + status='dynamic-unresolved')) + return facts, edges, diagnostics + + +def read_typescript(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]: + from msdmd.readers import _fact, _diagnostic, _edge, _subject_address + rid = 'typescript-compiler' + helper = Path(__file__).with_name('typescript-reader.cjs') + env = {key: value for key, value in os.environ.items() if key not in {'NODE_OPTIONS', 'NODE_PATH'}} + # Package resolution is rooted at the trusted helper, never the inspected repo. + result = subprocess.run(['node', str(helper)], input=json.dumps({'path': str(path), 'text': data.decode('utf-8-sig')}), + capture_output=True, text=True, cwd=helper.parent, env=env, check=False) + if result.returncode: + return [], [], [_diagnostic(context, reader_id=rid, code='typescript_reader_unavailable', + message='trusted TypeScript worker failed; install Node and run npm ci --prefix msdmd', status='unsupported')] + parsed = json.loads(result.stdout) + context = dict(context, convention_version=parsed['version'], dialect='typescript-compiler-jsdoc') + facts: list = [] + edges: list = [] + diagnostics = [_diagnostic(context, reader_id=rid, code=d['code'], + message=d.get('message', 'dynamic module loading is not resolved'), status=d['status'], + severity='error' if d['status'] == 'invalid' else 'warning', + location={'start_line': d['start_line'], 'end_line': d['end_line']}) for d in parsed['diagnostics']] + for index, item in enumerate(parsed['declarations']): + fact = _fact(context, reader_id=rid, kind='exported-declaration' if item['exported'] else 'symbol-declaration', + scope='symbol', identity=item['identity'], native_id=None if item.get('anonymous') else item['qualified_name'], value=item, + location={'start_line': item['start_line'], 'end_line': item['end_line']}) + fact['address'] = fact['subject']['address'] + '/fact/declaration' + facts.append(fact) + if item['exported']: + edges.append(_edge(_subject_address(context, 'module', context['file']), fact['subject']['address'], 'exports')) + for index, item in enumerate(parsed['docs']): + fact = _fact(context, reader_id=rid, kind='documentation', scope='symbol', identity=item['identity'], + value=item, location={'start_line': item['start_line'], 'end_line': item['end_line']}, + convention='typescript.documentation-comment', standing='declared') + fact['address'] = fact['subject']['address'] + f'/fact/documentation/{index}' + facts.append(fact) + for index, item in enumerate(sorted(parsed['comments'], key=lambda c: c['start_line'])): + scope = 'symbol' if item.get('identity') else 'module' + identity = item.get('identity') or context['file'] + fact = _fact(context, reader_id=rid, kind='comment', scope=scope, identity=identity, + value=item, location={'start_line': item['start_line'], 'end_line': item['end_line']}, native_id=str(index)) + facts.append(fact) + for tag in ('SPDX-License-Identifier', 'SPDX-FileCopyrightText'): + for match_ordinal, match in enumerate(re.finditer(re.escape(tag) + r':\s*([^\r\n]*?)(?:\*/|$)', item['text'], re.M)): + facts.append(_fact(context, reader_id=rid, kind='license-declaration', scope='module', identity=context['file'], + value={'tag': tag, 'value': match[1].strip()}, native_id=f'{tag}:{index}:{match_ordinal}', + location={'start_line': item['start_line'], 'end_line': item['end_line']}, convention='spdx.file-header', standing='declared')) + for index, item in enumerate(parsed['imports']): + fact = _fact(context, reader_id=rid, kind='dependency', scope='module', identity=context['file'], + value=item, native_id=str(index), location={'start_line': item['start_line'], 'end_line': item['end_line']}) + facts.append(fact) + edges.append(_edge(fact['subject']['address'], 'ecma-module:' + item['module'], item['kind'])) + for index, item in enumerate(parsed.get('exports', [])): + fact = _fact(context, reader_id=rid, kind='local-export', scope='module', identity=context['file'], + value=item, native_id=item['exported_name'], location={'start_line': item['start_line'], 'end_line': item['end_line']}) + fact['address'] = fact['subject']['address'] + f'/fact/local-export/{index}' + facts.append(fact) + targets = [_subject_address(context, 'symbol', identity) for identity in item['declaration_identities']] + fallback = 'ecma-local:' + item['local_name'] if item.get('local_name') else fact['address'] + for target in targets or [fallback]: + edges.append(_edge(fact['subject']['address'], target, 'exports:' + item['exported_name'])) + return facts, edges, diagnostics +# ratios: loc_comments=195:14 imports_exports=15:3 calls_definitions=83:3 diff --git a/msdmd/package-lock.json b/msdmd/package-lock.json new file mode 100644 index 0000000..a364aaa --- /dev/null +++ b/msdmd/package-lock.json @@ -0,0 +1,26 @@ +{ + "name": "msdmd-native-reader-runtime", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "msdmd-native-reader-runtime", + "dependencies": { + "typescript": "5.8.3" + } + }, + "node_modules/typescript": { + "version": "5.8.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", + "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + } + } +} diff --git a/msdmd/package.json b/msdmd/package.json new file mode 100644 index 0000000..2e4ce03 --- /dev/null +++ b/msdmd/package.json @@ -0,0 +1,6 @@ +{ + "name": "msdmd-native-reader-runtime", + "private": true, + "description": "Pinned syntax-only TypeScript parser for MSDMD; never loads inspected projects", + "dependencies": {"typescript": "5.8.3"} +} diff --git a/msdmd/readers.py b/msdmd/readers.py new file mode 100644 index 0000000..fdb54d9 --- /dev/null +++ b/msdmd/readers.py @@ -0,0 +1,1009 @@ +# ratios: loc_comments=889:48 imports_exports=22:5 calls_definitions=267:28 +# === MODULE_BUILD === +# id: msdmd_native_reader_registry +# module_name: readers +# module_kind: instrument +# summary: statically extracts supported native metadata conventions into provenance-bearing MSDMD facts +# owner: The Interdependency skill-lib +# public_surface: READER_MANIFESTS, readers_for, reader_for, read_native +# internal_surface: convention-specific pure readers and source-qualified fact helpers +# auth_boundary: none +# storage_boundary: read +# network_boundary: none +# user_data_boundary: read +# admin_only: false +# tests: tests/test_native_collection.py +# rollout: enable through msdmd.collect schema 2 collections +# rollback: retain schema 1 block-only consumers while removing the schema 2 runner claim +# === END MODULE_BUILD === +"""Static native metadata readers used by :mod:`msdmd.collect`. + +Usage guidance: + Call ``read_native(path, bytes, context)`` only with bytes already bounded + by the collector. Readers never import inspected Python, execute scripts, + expand templates, or resolve network references. ``READER_MANIFESTS`` is + emitted in every collection so consumers can negotiate the exact supported + subset instead of treating file recognition as full language support. + +The registry intentionally implements conventions exercised by skill-lib and +the MSDMD worked example: Python syntax/docstrings/imports, RATIOS boundary +lines, JSON documents, TOML manifests, Markdown YAML frontmatter, safe YAML and +JavaScript/TypeScript subsets, GitHub CODEOWNERS, shell declarations, systemd +units, Git ignore rules, Python requirements files, bounded license detection, +SVG document metadata, and root ``llms.txt`` structure. Unmatched inputs stay +visible in the collection discovery ledger as unsupported ``hmmm`` scope. +""" +from __future__ import annotations + +from functools import lru_cache +import datetime as dt +import hashlib +import io +import json +import math +import re +import shlex +import sys +import tokenize +import tomllib +import xml.etree.ElementTree as ET +from collections import Counter +from pathlib import Path +from typing import Any, Callable +from urllib.parse import quote + +from msdmd.parsers.universal import marker_for, parse_ratios, ratios_placement +from msdmd.formats import is_json_schema_uri, parse_json, parse_yaml, parse_xml +from msdmd.grammar_code import read_grammar +from msdmd.native_code import read_python as _read_python, read_typescript as _read_typescript +from msdmd.standards import read_standards + +READER_MANIFESTS: tuple[dict[str, Any], ...] = ({'reader_id': 'python-ast', + 'version': '2.0.0', + 'entry_point': 'msdmd.readers:_read_python', + 'dependencies': ['python-stdlib:ast', 'python-stdlib:tokenize', 'docstring-parser==0.18.0'], + 'convention': 'python.source-metadata', + 'specification': 'https://docs.python.org/3/reference/', + 'supported_versions': ['Python 3 syntax accepted by the running ast parser'], + 'feature_subset': ['qualified symbols and signatures', + 'AST/token comment attachment shared with module_projection', + 'ReST/Google/NumPy docstring fields', + 'lexically scoped imports', + 'literal __all__'], + 'detection': ['.py', '.pyi', '.pyw'], + 'scope_attachment': 'module and qualified symbol', + 'unknown_field_policy': 'preserve source expression or emit dynamic-unresolved diagnostic', + 'execution_policy': 'parse only; never import or evaluate', + 'support': 'implemented-and-tested', + 'known_limitations': ['runtime effects and dynamic imports/exports are not executed']}, + {'reader_id': 'msdmd-ratios', + 'version': '1.0.0', + 'entry_point': 'msdmd.readers:_read_ratios', + 'dependencies': ['msdmd.parsers.universal'], + 'convention': 'msdmd.ratios-line', + 'specification': 'The-Interdependency/skill-lib ratios/SKILL.md', + 'supported_versions': ['named ratios line v1'], + 'feature_subset': ['opening/closing placement', 'named ratio/value preservation'], + 'detection': ['supported line-comment source containing ratios:'], + 'scope_attachment': 'file boundary occurrence', + 'unknown_field_policy': 'preserve hmmm as an explicit value', + 'execution_policy': 'text parse only; never run ratio computers', + 'support': 'implemented-and-tested'}, + {'reader_id': 'json-stdlib', + 'version': '1.0.0', + 'entry_point': 'msdmd.readers:_read_json', + 'dependencies': ['python-stdlib:json'], + 'convention': 'json.document', + 'specification': 'RFC 8259', + 'supported_versions': ['RFC 8259 JSON'], + 'feature_subset': ['complete typed document tree', 'package.json dependency classes'], + 'detection': ['.json'], + 'scope_attachment': 'document and JSON Pointer', + 'unknown_field_policy': 'preserve in typed document tree', + 'execution_policy': 'parse only; no reference resolution', + 'support': 'implemented-and-tested'}, + {'reader_id': 'toml-stdlib', + 'version': '1.0.0', + 'entry_point': 'msdmd.readers:_read_toml', + 'dependencies': ['python-stdlib:tomllib'], + 'convention': 'toml.document', + 'specification': 'TOML 1.0.0 and Python packaging metadata specifications', + 'supported_versions': ['TOML accepted by the running tomllib parser'], + 'feature_subset': ['complete typed document tree', 'pyproject project/build dependency classes'], + 'detection': ['.toml'], + 'scope_attachment': 'document and TOML key path', + 'unknown_field_policy': 'preserve in typed document tree', + 'execution_policy': 'parse only; never invoke build backends', + 'support': 'implemented-and-tested'}, + {'reader_id': 'markdown-frontmatter', + 'version': '2.0.0', + 'entry_point': 'msdmd.readers:_read_markdown', + 'dependencies': ['PyYAML==6.0.3'], + 'convention': 'markdown.yaml-frontmatter', + 'specification': 'https://yaml.org/spec/1.2.2/', + 'supported_versions': ['YAML 1.2 core scalar subset with typed scalar-key preservation'], + 'feature_subset': ['nested frontmatter and typed values', 'safe acyclic aliases', 'multiline scalars'], + 'detection': ['.md', '.mdx'], + 'scope_attachment': 'document', + 'unknown_field_policy': 'preserve typed tree; reject duplicate keys, custom tags, cyclic aliases and merge ' + 'dialects', + 'execution_policy': 'text parse only; never execute MDX', + 'support': 'implemented-and-tested'}, + {'reader_id': 'yaml-core', + 'version': '2.0.0', + 'entry_point': 'msdmd.readers:_read_yaml', + 'dependencies': ['PyYAML==6.0.3'], + 'convention': 'yaml.core', + 'specification': 'https://yaml.org/spec/1.2.2/', + 'supported_versions': ['YAML 1.2 core with typed scalar-key preservation'], + 'feature_subset': ['typed nested mappings/sequences', + 'flow syntax', + 'acyclic aliases', + 'multiline scalars'], + 'known_limitations': ['custom tags, merge keys and cyclic aliases rejected; keys retain lexical strings'], + 'detection': ['.yml', '.yaml'], + 'scope_attachment': 'document and structural path', + 'unknown_field_policy': 'diagnose unsupported syntax; preserve raw source by digest', + 'execution_policy': 'text parse only; no tags, templates, actions, or includes', + 'support': 'implemented-and-tested'}, + {'reader_id': 'typescript-compiler', + 'version': '2.0.0', + 'entry_point': 'msdmd.readers:_read_typescript', + 'dependencies': ['Node.js', 'typescript==5.8.3'], + 'convention': 'typescript.source-metadata', + 'specification': 'https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html', + 'supported_versions': ['TypeScript 5.8.3 parser accepting JS/JSX/TS/TSX/MJS/MTS/CTS/CJS'], + 'feature_subset': ['syntax-tree symbol ownership', + 'multiline signatures', + 'imports and reexports', + 'compiler JSDoc tags with unknown tag text preserved'], + 'known_limitations': ['not a TSDoc validator', + 'no type checking, config loading, import resolution or target execution'], + 'detection': ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.mts', '.cts'], + 'scope_attachment': 'compiler AST module/symbol', + 'unknown_field_policy': 'retain raw documentation tags and report parse diagnostics', + 'execution_policy': 'trusted parser worker only; inspected code never executed', + 'support': 'implemented-and-tested'}, + {'reader_id': 'github-codeowners', + 'version': '1.0.0', + 'entry_point': 'msdmd.readers:_read_codeowners', + 'dependencies': [], + 'convention': 'github.codeowners', + 'specification': 'https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners', + 'supported_versions': ['GitHub CODEOWNERS line grammar'], + 'feature_subset': ['ordered pattern and owner extraction'], + 'detection': ['CODEOWNERS', '.github/CODEOWNERS', 'docs/CODEOWNERS'], + 'scope_attachment': 'ordered path rule', + 'unknown_field_policy': 'diagnose malformed rules; do not infer operational ownership', + 'execution_policy': 'text parse only', + 'support': 'implemented-and-tested'}, + {'reader_id': 'shell-static', + 'version': '1.0.0', + 'entry_point': 'msdmd.readers:_read_shell', + 'dependencies': [], + 'convention': 'shell.source-metadata', + 'specification': 'POSIX shebang convention and ShellCheck directives', + 'supported_versions': ['declaration extraction only'], + 'feature_subset': ['shebang', 'ShellCheck directives'], + 'detection': ['.sh', '.bash', '.zsh', '.fish', 'extensionless shebang scripts'], + 'scope_attachment': 'file', + 'unknown_field_policy': 'preserve directive text', + 'execution_policy': 'text parse only; never source or execute', + 'support': 'implemented-and-tested'}, + {'reader_id': 'systemd-unit', + 'version': '1.0.0', + 'entry_point': 'msdmd.readers:_read_systemd', + 'dependencies': [], + 'convention': 'systemd.unit', + 'specification': 'https://www.freedesktop.org/software/systemd/man/latest/systemd.syntax.html', + 'supported_versions': ['section/key/value declaration extraction'], + 'feature_subset': ['ordered sections', 'repeated directives', 'continuation lines'], + 'detection': ['.service', '.socket', '.timer', '.path', '.target'], + 'scope_attachment': 'unit section and directive occurrence', + 'unknown_field_policy': 'preserve key/value and order without interpreting runtime effect', + 'execution_policy': 'text parse only; never invoke systemd', + 'support': 'implemented-and-tested'}, + {'reader_id': 'gitignore-lines', + 'version': '1.0.0', + 'entry_point': 'msdmd.readers:_read_gitignore', + 'dependencies': [], + 'convention': 'git.ignore', + 'specification': 'https://git-scm.com/docs/gitignore', + 'supported_versions': ['ordered pattern declarations'], + 'feature_subset': ['pattern order', 'negation', 'anchoring', 'directory-only flag'], + 'detection': ['.gitignore'], + 'scope_attachment': 'repository path rule', + 'unknown_field_policy': 'preserve pattern text without evaluating matches', + 'execution_policy': 'text parse only; never invoke Git matching', + 'support': 'implemented-and-tested'}, + {'reader_id': 'python-requirements', + 'version': '1.0.0', + 'entry_point': 'msdmd.readers:_read_requirements', + 'dependencies': [], + 'convention': 'python.requirements-file', + 'specification': 'PyPA requirements file format', + 'supported_versions': ['one-line requirement and option subset'], + 'feature_subset': ['requirement text', 'package name', 'options', 'ordered source lines'], + 'known_limitations': ['does not resolve includes, environment markers, URLs, or indexes'], + 'detection': ['requirements*.txt', 'constraints*.txt'], + 'scope_attachment': 'requirements document line', + 'unknown_field_policy': 'preserve text and redact URL credentials', + 'execution_policy': 'text parse only; never install or resolve packages', + 'support': 'partial'}, + {'reader_id': 'license-text', + 'version': '1.0.0', + 'entry_point': 'msdmd.readers:_read_license', + 'dependencies': [], + 'convention': 'license.text', + 'specification': 'SPDX license identifiers plus exact known license headers', + 'supported_versions': ['MPL-2.0 exact header', 'SPDX-License-Identifier line'], + 'feature_subset': ['declared/detected expression', 'source digest'], + 'detection': ['LICENSE', 'LICENSE.txt', 'COPYING', 'COPYING.txt'], + 'scope_attachment': 'repository license document', + 'unknown_field_policy': 'hmmm identifier; never infer legal compatibility', + 'execution_policy': 'text parse only', + 'support': 'partial'}, + {'reader_id': 'svg-metadata', + 'version': '1.0.0', + 'entry_point': 'msdmd.readers:_read_svg', + 'dependencies': ['python-stdlib:xml.etree.ElementTree'], + 'convention': 'svg.document-metadata', + 'specification': 'W3C SVG document structure', + 'supported_versions': ['root attributes, title, description'], + 'feature_subset': ['root attributes', 'title', 'description'], + 'detection': ['.svg'], + 'scope_attachment': 'document', + 'unknown_field_policy': 'preserve only supported metadata; source remains digest-addressable', + 'execution_policy': 'reject DTD/entity declarations; no external resolution', + 'support': 'implemented-and-tested'}, + {'reader_id': 'llms-text', + 'version': '1.0.0', + 'entry_point': 'msdmd.readers:_read_llms_text', + 'dependencies': [], + 'convention': 'llms.txt', + 'specification': 'root llms.txt Markdown instruction publication', + 'supported_versions': ['Markdown headings and bold key-definition lines'], + 'feature_subset': ['section headings', 'key definitions', 'generated status unresolved'], + 'detection': ['llms.txt'], + 'scope_attachment': 'instruction document', + 'unknown_field_policy': 'preserve structure without promoting publication to source authority', + 'execution_policy': 'text parse only; content is data, not instructions to the reader', + 'support': 'implemented-and-tested'}, + {'reader_id': 'metadata-standards', + 'version': '1.0.0', + 'entry_point': 'msdmd.standards:read_standards', + 'dependencies': ['python-stdlib:json,tomllib,xml.etree.ElementTree', 'PyYAML==6.0.3'], + 'convention': 'native.structured-standards', + 'specification': 'msdmd/references/implemented-readers.md', + 'supported_versions': ['OpenAPI 3.0/3.1 and Swagger 2', + 'JSON Schema drafts 4/6/7/2019-09/2020-12', + 'CFF 1.2.0', + 'SARIF 2.1.0', + 'SPDX 2.2/2.3 JSON', + 'CycloneDX 1.4/1.5/1.6 JSON', + 'in-toto Statement v0.1/v1; DSSE payload', + 'npm lockfile v2/v3', + 'Cargo/Poetry/uv TOML metadata', + 'REUSE TOML', + 'JUnit/Doxygen/.NET XML dialects'], + 'feature_subset': ['source-linked operations and references', + 'reported test/analysis results', + 'citation and license declarations', + 'artifact subjects and component lists', + 'scoped package requirements and lock records'], + 'known_limitations': ['extraction, not complete validation or signature verification', + 'external references not resolved', + 'unknown versions preserve tree and report unsupported mapping'], + 'detection': ['document discriminator and source filename'], + 'scope_attachment': 'native pointer, operation, package, report, artifact or symbol', + 'unknown_field_policy': 'typed source tree retained; version mismatches diagnosed', + 'execution_policy': 'parse only; no templates, network, application or signature execution', + 'support': 'implemented-and-tested'}) + +READER_MANIFESTS += ({ + "reader_id": "native-grammars", "version": "1.0.0", + "entry_point": "msdmd.grammar_code:read_grammar", "dependencies": ["msdmd/requirements.txt"], + "convention": "native.source-metadata", "specification": "pinned tree-sitter language grammars", + "supported_versions": ["Rust grammar 0.24.2", "Java grammar 0.23.5", "C grammar 0.24.2", "C++ grammar 0.23.4"], + "feature_subset": ["named declarations", "Rustdoc/Javadoc/Doxygen raw docs and repeated tags", "imports", "attributes", "SPDX headers"], + "detection": [".rs", ".java", ".c", ".cc", ".cpp", ".cxx", ".hpp", ".hxx", ".h (ambiguous)"], + "scope_attachment": "lexical symbols and adjacent documentation", + "unknown_field_policy": "preserve raw documentation and syntax; diagnose macro/conditional context", + "execution_policy": "parse only; no compiler, macro expansion or annotation processing", "support": "partial", +},) +_MANIFESTS = {item["reader_id"]: item for item in READER_MANIFESTS} +_PYTHON_SUFFIXES = {".py", ".pyi", ".pyw"} +_MARKDOWN_SUFFIXES = {".md", ".mdx"} +_YAML_SUFFIXES = {".yml", ".yaml"} +_TYPESCRIPT_SUFFIXES = {".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"} +_SHELL_SUFFIXES = {".sh", ".bash", ".zsh", ".fish"} +_SYSTEMD_SUFFIXES = {".service", ".socket", ".timer", ".path", ".target"} +_GENERATED_MARKER = "Generated by tools/build_codex_plugin_skills.py; do not edit." +_SENSITIVE_KEY_RE = re.compile(r"(?:^|[_-])(?:secret|token|password|passwd|api[_-]?key|private[_-]?key|credential|client[_-]?secret|access[_-]?key)(?:$|[_-])", re.IGNORECASE) + + +def _digest(value: bytes | str) -> str: + data = value if isinstance(value, bytes) else value.encode("utf-8") + return hashlib.sha256(data).hexdigest() + + +def _json_safe(value: Any) -> Any: + """Preserve non-JSON native scalar types with explicit tagged values.""" + if value is None or isinstance(value, (str, bool, int)): + return value + if isinstance(value, float): + return value if math.isfinite(value) else {"$type": "nonfinite-float", "value": repr(value)} + if isinstance(value, (dt.datetime, dt.date, dt.time)): + return {"$type": f"toml-{type(value).__name__}", "value": value.isoformat()} + if isinstance(value, dict): + return {str(key): _json_safe(item) for key, item in value.items()} + if isinstance(value, (list, tuple)): + return [_json_safe(item) for item in value] + return {"$type": f"unsupported:{type(value).__name__}", "value": repr(value)} + + +def _redact_sensitive(value: Any, pointer: str = "") -> tuple[Any, list[str]]: + """Redact values owned by plainly secret-bearing field names.""" + redacted: list[str] = [] + if isinstance(value, dict): + result: dict[str, Any] = {} + for key, item in value.items(): + child_pointer = f"{pointer}/{key}" + if _SENSITIVE_KEY_RE.search(str(key)): + result[str(key)] = {"$redacted": True, "reason": "sensitive-field-name"} + redacted.append(child_pointer) + else: + result[str(key)], child_redacted = _redact_sensitive(item, child_pointer) + redacted.extend(child_redacted) + return result, redacted + if isinstance(value, list): + result_list: list[Any] = [] + for index, item in enumerate(value): + child, child_redacted = _redact_sensitive(item, f"{pointer}/{index}") + result_list.append(child) + redacted.extend(child_redacted) + return result_list, redacted + if isinstance(value, str): + sanitized = re.sub(r"(\b[a-zA-Z][a-zA-Z0-9+.-]*://)[^/@\s]+@", r"\1[redacted]@", value) + if sanitized != value: + return sanitized, [pointer] + return value, redacted + + +def _redaction_diagnostic(context: dict[str, Any], reader_id: str, pointers: list[str]) -> dict[str, Any] | None: + if not pointers: + return None + return _diagnostic( + context, + reader_id=reader_id, + code="sensitive_fields_redacted", + message=f"withheld {len(pointers)} sensitive field value(s)", + status="redacted", + severity="warning", + ) + + +def _quoted(value: str, *, path: bool = False) -> str: + return quote(value, safe="/" if path else "") + + +def _source(context: dict[str, Any], location: dict[str, Any]) -> dict[str, Any]: + return { + "repository": context["repo"], + "revision": context["revision"], + "file": context["file"], + "content_sha256": context["content_sha256"], + "location": location, + } + + +def _subject_address(context: dict[str, Any], scope: str, identity: str) -> str: + return ( + f"msdmd://{_quoted(context['repo'])}@{_quoted(context['revision'])}/{_quoted(context['file'], path=True)}" + f"#subject/{_quoted(scope)}/{_quoted(identity)}" + ) + + +def _fact( + context: dict[str, Any], + *, + reader_id: str, + kind: str, + scope: str, + identity: str, + location: dict[str, Any], + value: Any, + native_id: str | None = None, + convention: str | None = None, + standing: str = "syntactically-observed", + projection: dict[str, Any] | None = None, +) -> dict[str, Any]: + subject = _subject_address(context, scope, identity) + pointer = location.get("pointer") or f"lines:{location.get('start_line', '?')}-{location.get('end_line', '?')}" + native_component = f"/{_quoted(native_id)}" if native_id is not None else "" + address = f"{subject}/fact/{_quoted(kind)}/{_quoted(str(pointer))}{native_component}" + result = { + "address": address, + "origin": "native", + "kind": kind, + "source": _source(context, location), + "subject": { + "address": subject, + "scope": scope, + "identity": identity, + }, + "convention": { + "namespace": convention or _MANIFESTS[reader_id]["convention"], + "version": context.get("convention_version", "hmmm"), + "dialect": context.get("dialect", "hmmm"), + }, + "native": {"id": native_id, "value": _json_safe(value)}, + "standing": standing, + "extraction": { + "reader_id": reader_id, + "reader_version": _MANIFESTS[reader_id]["version"], + "support": _MANIFESTS[reader_id]["support"], + "configuration_sha256": context["configuration_sha256"], + }, + } + if projection is not None: + result["projection"] = projection + return result + + +def _diagnostic( + context: dict[str, Any], + *, + reader_id: str, + code: str, + message: str, + status: str, + severity: str = "warning", + location: dict[str, Any] | None = None, +) -> dict[str, Any]: + return { + "code": code, + "severity": severity, + "status": status, + "message": message, + "source": _source(context, location or {"pointer": "document"}), + "reader_id": reader_id, + } + + +def _edge(source: str, target: str, kind: str, *, standing: str = "syntactically-observed") -> dict[str, Any]: + return { + "from": source, + "to": target, + "kind": kind, + "standing": standing, + "target_resolution": "external-or-unresolved", + } + + +def _read_ratios(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]: + reader_id = "msdmd-ratios" + marker = marker_for(path) + if marker is None: + return [], [], [] + context = dict(context, convention_version="named ratios line v1", dialect=f"line-comment:{marker}") + try: + if path.suffix.lower() in _PYTHON_SUFFIXES: + encoding, _ = tokenize.detect_encoding(io.BytesIO(data).readline) + source = data.decode(encoding).replace("\r\n", "\n").replace("\r", "\n") + comments = [""] * len(source.split("\n")) + for token in tokenize.generate_tokens(io.StringIO(source).readline): + if token.type == tokenize.COMMENT: + comments[token.start[0] - 1] = token.string + text = "\n".join(comments) + else: + source = data.decode("utf-8") + text = context.get("comment_source", source) + except (SyntaxError, UnicodeDecodeError, tokenize.TokenError, IndentationError) as exc: + return [], [], [_diagnostic(context, reader_id=reader_id, code="undecodable_ratios_source", message=str(exc), status="invalid", severity="error")] + facts: list[dict] = [] + diagnostics: list[dict] = [] + occurrence: Counter[str] = Counter() + for line_number, line in enumerate(text.splitlines(), start=1): + for entry in parse_ratios(line, marker): + ratio_id = str(entry["id"]) + occurrence[ratio_id] += 1 + identity = f"{ratio_id}[{occurrence[ratio_id]}]" + facts.append(_fact(context, reader_id=reader_id, kind="composition-ratio", scope="file", identity=identity, location={"start_line": line_number, "end_line": line_number}, value={"ratio": ratio_id, "value": str(entry["value"]), "occurrence": occurrence[ratio_id]}, native_id=ratio_id, convention="msdmd.ratios-line", standing="declared")) + if facts: + opening, closing = ratios_placement(source, marker) + if not opening or not closing: + diagnostics.append(_diagnostic(context, reader_id=reader_id, code="misplaced_ratios_boundary", message=f"opening={opening} closing={closing}", status="invalid", severity="error")) + return facts, [], diagnostics + + +def _read_json(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]: + reader_id = "json-stdlib" + context = dict(context, convention_version="RFC 8259", dialect="json") + try: + value = parse_json(data) + except (UnicodeDecodeError, ValueError) as exc: + return [], [], [_diagnostic(context, reader_id=reader_id, code="invalid_json", message=str(exc), status="invalid", severity="error")] + value, redacted = _redact_sensitive(value) + if path.name == "package.json": + convention = "npm.package-json" + elif path.name.endswith(".schema.json") or (isinstance(value, dict) and is_json_schema_uri(value.get("$schema"))): + convention = "json.schema" + context["convention_version"] = str(value.get("$schema", "hmmm")) if isinstance(value, dict) else "hmmm" + elif isinstance(value, dict) and "openapi" in value: + convention = "openapi.document" + context["convention_version"] = str(value["openapi"]) + elif context["file"] == "skills.json": + convention = "skill-lib.skills-index" + elif context["file"] == ".codex-plugin/plugin.json": + convention = "codex.plugin-manifest" + elif context["file"] == ".claude-plugin/marketplace.json": + convention = "claude.plugin-marketplace" + else: + convention = "json.document" + facts = [_fact(context, reader_id=reader_id, kind="structured-document", scope="document", identity=context["file"], location={"pointer": ""}, value=value, convention=convention)] + edges: list[dict] = [] + if path.name == "package.json" and isinstance(value, dict): + subject = _subject_address(context, "document", context["file"]) + for field, kind in (("dependencies", "runtime"), ("devDependencies", "development"), ("peerDependencies", "peer"), ("optionalDependencies", "optional")): + dependencies = value.get(field, {}) + if isinstance(dependencies, dict): + for name, constraint in dependencies.items(): + facts.append(_fact(context, reader_id=reader_id, kind="dependency", scope="package", identity=str(value.get("name", context["file"])), location={"pointer": f"/{field}/" + str(name).replace("~", "~0").replace("/", "~1")}, value={"name": name, "constraint": constraint, "class": kind}, native_id=name, convention=convention, projection={"mapping_version": "npm-dependencies@1", "relation": "depends_on", "loss": "none"})) + edges.append(_edge(subject, f"npm-package:{name}", f"depends_on:{kind}")) + diagnostic = _redaction_diagnostic(context, reader_id, redacted) + return facts, edges, [diagnostic] if diagnostic else [] + + +def _read_toml(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]: + reader_id = "toml-stdlib" + context = dict(context, convention_version="TOML 1.0.0", dialect="toml") + try: + value = tomllib.loads(data.decode("utf-8")) + except (UnicodeDecodeError, tomllib.TOMLDecodeError) as exc: + return [], [], [_diagnostic(context, reader_id=reader_id, code="invalid_toml", message=str(exc), status="invalid", severity="error")] + value, redacted = _redact_sensitive(value) + convention = "python.pyproject" if path.name == "pyproject.toml" else "toml.document" + facts = [_fact(context, reader_id=reader_id, kind="structured-document", scope="document", identity=context["file"], location={"pointer": ""}, value=value, convention=convention)] + edges: list[dict] = [] + if path.name == "pyproject.toml": + project = value.get("project", {}) if isinstance(value, dict) else {} + package = str(project.get("name", context["file"])) if isinstance(project, dict) else context["file"] + subject = _subject_address(context, "package", package) + groups: list[tuple[str, Any, str]] = [ + ("/project/dependencies", project.get("dependencies", []) if isinstance(project, dict) else [], "runtime"), + ("/build-system/requires", value.get("build-system", {}).get("requires", []) if isinstance(value.get("build-system", {}), dict) else [], "build"), + ] + optional = project.get("optional-dependencies", {}) if isinstance(project, dict) else {} + if isinstance(optional, dict): + groups.extend((f"/project/optional-dependencies/{group}", deps, f"optional:{group}") for group, deps in optional.items()) + for pointer, dependencies, kind in groups: + if not isinstance(dependencies, list): + continue + for index, dependency in enumerate(dependencies): + if not isinstance(dependency, str): + continue + name = re.split(r"[<>=!~;\[\s]", dependency, maxsplit=1)[0] + facts.append(_fact(context, reader_id=reader_id, kind="dependency", scope="package", identity=package, location={"pointer": f"{pointer}/{index}"}, value={"requirement": dependency, "name": name, "class": kind}, native_id=name, convention=convention, projection={"mapping_version": "pyproject-dependencies@1", "relation": "depends_on", "loss": "marker retained in requirement"})) + edges.append(_edge(subject, f"python-package:{name}", f"depends_on:{kind}")) + diagnostic = _redaction_diagnostic(context, reader_id, redacted) + return facts, edges, [diagnostic] if diagnostic else [] + + +def _read_markdown(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]: + reader_id = "markdown-frontmatter" + text = data.decode("utf-8-sig").replace("\r\n", "\n") + if not text.startswith("---\n"): + return [], [], [] + match = re.search(r"^---[ \t]*$", text[4:], re.M) + if match is None: + raise ValueError("unterminated YAML frontmatter") + raw = text[4:4 + match.start()] + value = parse_yaml(raw.encode("utf-8")) + value, redacted = _redact_sensitive(value) + context = dict(context, convention_version="YAML 1.2 core", dialect="yaml-frontmatter") + facts = [_fact(context, reader_id=reader_id, kind="frontmatter", scope="document", identity=context["file"], + location={"start_line": 1, "end_line": raw.count("\n") + 2}, + value={"fields": value, "raw_source": "source-reference", "generated": _GENERATED_MARKER in text}, + convention="markdown.yaml-frontmatter", standing="derived" if _GENERATED_MARKER in text else "declared")] + diagnostic = _redaction_diagnostic(context, reader_id, redacted) + return facts, [], [diagnostic] if diagnostic else [] + + +def _read_yaml(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]: + reader_id = "yaml-core" + value, redacted = _redact_sensitive(parse_yaml(data)) + context = dict(context, convention_version="YAML 1.2 core", dialect="yaml-core-string-keys") + fact = _fact(context, reader_id=reader_id, kind="structured-document", scope="document", identity=context["file"], + location={"pointer": ""}, value=value, convention="yaml.document") + diagnostic = _redaction_diagnostic(context, reader_id, redacted) + return [fact], [], [diagnostic] if diagnostic else [] + + +def _read_codeowners(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]: + reader_id = "github-codeowners" + context = dict(context, convention_version="GitHub current documented grammar", dialect="github") + try: + text = data.decode("utf-8") + except UnicodeDecodeError as exc: + return [], [], [_diagnostic(context, reader_id=reader_id, code="undecodable_source", message=str(exc), status="invalid", severity="error")] + facts: list[dict] = [] + diagnostics: list[dict] = [] + for line_number, raw in enumerate(text.splitlines(), start=1): + stripped = raw.strip() + if not stripped or stripped.startswith("#"): + continue + try: + parts = shlex.split(raw, comments=True, posix=True) + except ValueError as exc: + diagnostics.append(_diagnostic(context, reader_id=reader_id, code="invalid_codeowners_rule", message=str(exc), status="invalid", severity="error", location={"start_line": line_number, "end_line": line_number})) + continue + if not parts: + continue + if parts[0].startswith("!") or "[" in parts[0] or "\\#" in raw: + diagnostics.append(_diagnostic(context, reader_id=reader_id, code="unsupported_codeowners_pattern", + message="GitHub CODEOWNERS does not support this ignore-pattern feature", status="unsupported")) + facts.append(_fact(context, reader_id=reader_id, kind="review-ownership", scope="path-rule", identity=f"rule:{len(facts)}", location={"start_line": line_number, "end_line": line_number}, value={"pattern": parts[0], "owners": parts[1:], "precedence": line_number, "authority": "review-assignment-only", "provider_source": "active" if context.get("codeowners_source") == context["file"] else "shadowed"}, native_id=parts[0], convention="github.codeowners", projection={"mapping_version": "github-codeowners@1", "canonical_field": "review_owners", "loss": "does not imply operational ownership or permissions"})) + return facts, [], diagnostics + + +def _read_shell(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]: + reader_id = "shell-static" + context = dict(context, convention_version="source declaration v1", dialect=path.suffix.lstrip(".") or "shebang") + try: + text = data.decode("utf-8") + except UnicodeDecodeError as exc: + return [], [], [_diagnostic(context, reader_id=reader_id, code="undecodable_source", message=str(exc), status="invalid", severity="error")] + facts: list[dict] = [] + lines = text.splitlines() + if lines and lines[0].startswith("#!"): + facts.append(_fact(context, reader_id=reader_id, kind="interpreter", scope="file", identity=context["file"], location={"start_line": 1, "end_line": 1}, value={"shebang": lines[0][2:].strip()}, native_id="shebang", convention="posix.shebang")) + for number, line in enumerate(lines, start=1): + match = re.match(r"^\s*#\s*shellcheck\s+(?P.+?)\s*$", line, re.IGNORECASE) + if match: + facts.append(_fact(context, reader_id=reader_id, kind="tool-directive", scope="file", identity=context["file"], location={"start_line": number, "end_line": number}, value={"tool": "shellcheck", "directive": match.group("body")}, native_id=f"shellcheck:{number}", convention="shellcheck.directive")) + return facts, [], [] + + +def _redact_systemd_environment(value: str) -> tuple[str, bool, bool]: + """Redact every assignment in the supported, non-escaped word subset. + + Unknown quoting/escaping withholds the entire value rather than + applying shell rules to systemd syntax or publishing possible secrets. + """ + parts: list[str] = [] + position = 0 + redacted = False + while position < len(value): + start = position + while position < len(value) and value[position].isspace(): + position += 1 + parts.append(value[start:position]) + if position == len(value): + break + start = position + quote_char = value[position] if value[position] in (chr(34), chr(39)) else '' + if quote_char: + end = value.find(quote_char, position + 1) + if end < 0 or (end + 1 < len(value) and not value[end + 1].isspace()): + return '', True, True + word = value[position + 1:end] + position = end + 1 + else: + while position < len(value) and not value[position].isspace(): + position += 1 + word = value[start:position] + if chr(34) in word or chr(39) in word: + return '', True, True + if chr(92) in word: + return '', True, True + name, separator, assigned = word.partition('=') + if not separator or not re.fullmatch(r'[A-Za-z_][A-Za-z0-9_]*', name): + return '', True, True + if _SENSITIVE_KEY_RE.search(name): + parts.append(quote_char + name + '=' + quote_char) + redacted = True + else: + parts.append(value[start:position]) + return ''.join(parts), redacted, False + + +def _read_systemd(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]: + reader_id = "systemd-unit" + context = dict(context, convention_version="systemd.syntax current documented grammar", dialect=path.suffix.lstrip(".")) + try: + text = data.decode("utf-8") + except UnicodeDecodeError as exc: + return [], [], [_diagnostic(context, reader_id=reader_id, code="undecodable_source", message=str(exc), status="invalid", severity="error")] + facts: list[dict] = [] + diagnostics: list[dict] = [] + section = "hmmm" + logical = "" + logical_start = 1 + occurrence: dict[tuple[str, str], int] = {} + for number, raw in enumerate(text.splitlines(), start=1): + stripped = raw.strip() + if not stripped or stripped.startswith(("#", ";")): + continue + if not logical: + logical_start = number + if stripped.endswith(chr(92)): + logical += stripped[:-1] + ' ' + continue + logical += stripped + line = logical + logical = "" + if line.startswith("[") and line.endswith("]"): + section = line[1:-1] + continue + if "=" not in line: + diagnostics.append(_diagnostic(context, reader_id=reader_id, code="invalid_systemd_directive", message="expected key=value", status="invalid", severity="error", location={"start_line": logical_start, "end_line": number})) + continue + key, value = (part.strip() for part in line.split("=", 1)) + published_value = value + if key.lower() == 'environment': + published_value, redacted, unsupported = _redact_systemd_environment(value) + location = {'start_line': logical_start, 'end_line': number} + if redacted: + diagnostics.append(_diagnostic(context, reader_id=reader_id, code='sensitive_fields_redacted', + message='withheld potentially sensitive systemd Environment values', status='redacted', location=location)) + if unsupported: + diagnostics.append(_diagnostic(context, reader_id=reader_id, code='unsupported_systemd_environment_syntax', + message='Environment quoting or escaping is outside the supported subset; value withheld', status='unsupported', location=location)) + identity_key = (section, key) + occurrence[identity_key] = occurrence.get(identity_key, 0) + 1 + identity = f"{section}.{key}[{occurrence[identity_key]}]" + facts.append(_fact(context, reader_id=reader_id, kind="unit-directive", scope="configuration", identity=identity, location={"start_line": logical_start, "end_line": number}, value={"section": section, "key": key, "value": published_value, "occurrence": occurrence[identity_key]}, native_id=key, convention="systemd.unit")) + if logical: + diagnostics.append(_diagnostic(context, reader_id=reader_id, code="truncated_systemd_continuation", message="file ends during a continuation", status="invalid", severity="error")) + return facts, [], diagnostics + + +def _read_gitignore(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]: + reader_id = "gitignore-lines" + context = dict(context, convention_version="gitignore current documented grammar", dialect="gitignore") + try: + text = data.decode("utf-8") + except UnicodeDecodeError as exc: + return [], [], [_diagnostic(context, reader_id=reader_id, code="undecodable_source", message=str(exc), status="invalid", severity="error")] + facts: list[dict] = [] + order = 0 + for line_number, raw in enumerate(text.splitlines(), start=1): + # Git ignores unescaped trailing spaces. Count backslash parity so + # an escaped space survives, including before later unescaped spaces. + while raw.endswith(' '): + prefix = raw[:-1] + if (len(prefix) - len(prefix.rstrip('\\'))) % 2: + break + raw = prefix + if not raw or raw.startswith("#"): + continue + order += 1 + negated = raw.startswith("!") and not raw.startswith("\\!") + pattern = raw[1:] if negated else raw + facts.append(_fact(context, reader_id=reader_id, kind="ignore-rule", scope="path-rule", identity=f"rule:{order}", location={"start_line": line_number, "end_line": line_number}, value={"pattern": pattern, "negated": negated, "anchored": pattern.startswith("/"), "directory_only": pattern.endswith("/"), "order": order}, native_id=pattern, convention="git.ignore", standing="declared")) + return facts, [], [] + + +_REQUIREMENT_NAME_RE = re.compile(r"^(?P[A-Za-z0-9][A-Za-z0-9._-]*)") + + +def _read_requirements(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]: + reader_id = "python-requirements" + context = dict(context, convention_version="PyPA requirements file subset v1", dialect="requirements") + try: + text = data.decode("utf-8") + except UnicodeDecodeError as exc: + return [], [], [_diagnostic(context, reader_id=reader_id, code="undecodable_source", message=str(exc), status="invalid", severity="error")] + facts: list[dict] = [] + edges: list[dict] = [] + diagnostics: list[dict] = [] + subject = _subject_address(context, "requirements-document", context["file"]) + order = 0 + for line_number, raw in enumerate(text.splitlines(), start=1): + stripped = raw.strip() + if not stripped or stripped.startswith("#"): + continue + order += 1 + published = re.sub(r"(?<=://)[^/@\s]+@", "@", stripped) + if published != stripped: + diagnostics.append(_diagnostic(context, reader_id=reader_id, code="sensitive_fields_redacted", message="withheld requirement URL credentials", status="redacted", severity="warning", location={"start_line": line_number, "end_line": line_number})) + if published.startswith("-"): + if published.startswith(('-r', '-c')) or re.match(r'^--(?:requirement|constraint)(?:[=\s]|$)', published): + diagnostics.append(_diagnostic(context, reader_id=reader_id, code='unresolved_requirement_include', + message='included requirements/constraints are declared but not resolved', status='dynamic-unresolved', + location={'start_line': line_number, 'end_line': line_number})) + facts.append(_fact(context, reader_id=reader_id, kind="requirements-option", scope="requirements-document", identity=f"option:{order}", location={"start_line": line_number, "end_line": line_number}, value={"text": published, "order": order}, native_id=f"option:{order}", convention="python.requirements-file", standing="declared")) + continue + match = _REQUIREMENT_NAME_RE.match(published) + name = match.group("name") if match else "hmmm" + facts.append(_fact(context, reader_id=reader_id, kind="dependency", scope="requirements-document", identity=f"requirement:{order}", location={"start_line": line_number, "end_line": line_number}, value={"requirement": published, "name": name, "class": "runtime-or-unresolved", "order": order}, native_id=name if name != "hmmm" else None, convention="python.requirements-file", standing="declared", projection={"mapping_version": "requirements-lines@1", "relation": "depends_on", "loss": "resolution and environment markers not evaluated"})) + if name != "hmmm": + edges.append(_edge(subject, f"python-package:{name}", "depends_on:runtime-or-unresolved")) + return facts, edges, diagnostics + + +def _read_license(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]: + reader_id = "license-text" + context = dict(context, convention_version="detector v1", dialect="license-text") + try: + text = data.decode("utf-8") + except UnicodeDecodeError as exc: + return [], [], [_diagnostic(context, reader_id=reader_id, code="undecodable_source", message=str(exc), status="invalid", severity="error")] + spdx_match = re.search(r"SPDX-License-Identifier:\s*(?P[^\r\n]+)", text) + if spdx_match: + expression = spdx_match.group("value").strip() + method = "declared-spdx-line" + elif text.startswith("Mozilla Public License Version 2.0"): + expression = "MPL-2.0" + method = "exact-known-header" + else: + expression = "hmmm" + method = "unrecognized-text" + fact = _fact(context, reader_id=reader_id, kind="license-declaration", scope="document", identity=context["file"], location={"pointer": "document"}, value={"expression": expression, "detection_method": method, "legal_interpretation": "not-performed", "text": "source-reference"}, native_id=expression if expression != "hmmm" else None, convention="license.text", standing="declared" if method == "declared-spdx-line" else "derived") + diagnostics = [] if expression != "hmmm" else [_diagnostic(context, reader_id=reader_id, code="unrecognized_license_text", message="license identifier remains hmmm", status="ambiguous", severity="warning")] + return [fact], [], diagnostics + + +def _read_svg(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]: + reader_id = 'svg-metadata' + context = dict(context, convention_version='SVG document subset v1', dialect='xml') + try: + root = parse_xml(data) + except (UnicodeDecodeError, ValueError, ET.ParseError) as exc: + return [], [], [_diagnostic(context, reader_id=reader_id, code='invalid_svg_xml', + message=type(exc).__name__ + '; SVG rejected by bounded XML parser', status='invalid', severity='error')] + if root.tag.rsplit('}', 1)[-1] != 'svg': + return [], [], [_diagnostic(context, reader_id=reader_id, code='unexpected_svg_root', + message='expected svg root', status='invalid', severity='error')] + title = None + description = None + for child in root: + child_name = child.tag.rsplit('}', 1)[-1] + if child_name == 'title' and title is None: + title = ''.join(child.itertext()).strip() + elif child_name == 'desc' and description is None: + description = ''.join(child.itertext()).strip() + value = {'attributes': dict(root.attrib), 'title': title, 'description': description} + return [_fact(context, reader_id=reader_id, kind='document-metadata', scope='document', identity=context['file'], + location={'pointer': '/svg'}, value=value, convention='svg.document-metadata')], [], [] + + +_LLMS_HEADING_RE = re.compile(r"^(?P#{1,6})\s+(?P.+?)\s*$") +_LLMS_DEFINITION_RE = re.compile(r"^-\s+\*\*(?P<term>.+?)\*\*\s*=\s*(?P<definition>.+?)\s*$") + + +def _read_llms_text(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]: + reader_id = "llms-text" + context = dict(context, convention_version="Markdown structural subset v1", dialect="llms.txt") + try: + text = data.decode("utf-8") + except UnicodeDecodeError as exc: + return [], [], [_diagnostic(context, reader_id=reader_id, code="undecodable_source", message=str(exc), status="invalid", severity="error")] + facts: list[dict] = [] + for line_number, line in enumerate(text.splitlines(), start=1): + heading = _LLMS_HEADING_RE.match(line) + if heading: + title = heading.group("title") + facts.append(_fact(context, reader_id=reader_id, kind="instruction-section", scope="document-section", identity=f"heading:{line_number}", location={"start_line": line_number, "end_line": line_number}, value={"level": len(heading.group("marks")), "title": title, "generated": "hmmm"}, native_id=title, convention="llms.txt", standing="declared")) + continue + definition = _LLMS_DEFINITION_RE.match(line) + if definition: + term = definition.group("term") + facts.append(_fact(context, reader_id=reader_id, kind="key-definition", scope="instruction-definition", identity=term, location={"start_line": line_number, "end_line": line_number}, value={"term": term, "definition": definition.group("definition"), "generated": "hmmm"}, native_id=term, convention="llms.txt", standing="declared")) + return facts, [], [] + + +@lru_cache(maxsize=1) +def implementation_digest() -> str: + """Identity of all executable reader inputs, independent of inspected files.""" + names = ("readers.py", "native_code.py", "grammar_code.py", "formats.py", "standards.py", "module_projection.py", "typescript-reader.cjs", "requirements.txt", "package.json", "package-lock.json", "module-projection.schema.json", "python-module-reader.json", "parsers/universal.py") + digest = hashlib.sha256() + for name in names: + digest.update(name.encode()) + digest.update((Path(__file__).parent / name).read_bytes()) + return digest.hexdigest() + + +Reader = Callable[[Path, bytes, dict[str, Any]], tuple[list[dict], list[dict], list[dict]]] + + +def readers_for(path: Path, data: bytes | None = None) -> list[tuple[str, Reader]]: + """Return every compatible reader selected for ``path``.""" + suffix = path.suffix.lower() + relative = path.as_posix() + selected: list[tuple[str, Reader]] = [] + if path.name == "CODEOWNERS" and relative in {"CODEOWNERS", ".github/CODEOWNERS", "docs/CODEOWNERS"}: + selected.append(("github-codeowners", _read_codeowners)) + elif suffix in _PYTHON_SUFFIXES: + selected.append(("python-ast", _read_python)) + elif suffix in {".json", ".sarif", ".ipynb"}: + selected.append(("json-stdlib", _read_json)) + elif suffix == ".toml" or path.name in {"Cargo.lock", "poetry.lock", "uv.lock"}: + selected.append(("toml-stdlib", _read_toml)) + elif suffix in _MARKDOWN_SUFFIXES: + selected.append(("markdown-frontmatter", _read_markdown)) + elif suffix in _YAML_SUFFIXES or suffix == ".cff": + selected.append(("yaml-core", _read_yaml)) + elif suffix in _TYPESCRIPT_SUFFIXES: + selected.append(("typescript-compiler", _read_typescript)) + elif suffix in {".rs", ".java", ".c", ".cc", ".cpp", ".cxx", ".hpp", ".hxx", ".h"}: + selected.append(("native-grammars", read_grammar)) + elif suffix in _SHELL_SUFFIXES: + selected.append(("shell-static", _read_shell)) + elif suffix in _SYSTEMD_SUFFIXES: + selected.append(("systemd-unit", _read_systemd)) + elif path.name == ".gitignore": + selected.append(("gitignore-lines", _read_gitignore)) + elif (path.name.startswith("requirements") or path.name.startswith("constraints")) and suffix == ".txt": + selected.append(("python-requirements", _read_requirements)) + elif path.name in {"LICENSE", "LICENSE.txt", "COPYING", "COPYING.txt"} or (path.parent.name == "LICENSES" and suffix == ".txt"): + selected.append(("license-text", _read_license)) + elif suffix == ".svg": + selected.append(("svg-metadata", _read_svg)) + elif path.name == "llms.txt": + selected.append(("llms-text", _read_llms_text)) + elif not suffix and data is not None and data.startswith(b"#!"): + selected.append(("shell-static", _read_shell)) + if suffix in {".json", ".sarif", ".ipynb", ".yaml", ".yml", ".cff", ".toml", ".xml", ".spdx", ".license"} or path.name in {"Cargo.lock", "poetry.lock", "uv.lock"}: + selected.append(("metadata-standards", read_standards)) + if data is not None and b"ratios:" in data and marker_for(path) is not None: + selected.append(("msdmd-ratios", _read_ratios)) + return selected + + +def reader_for(path: Path, data: bytes | None = None) -> tuple[str, Reader] | None: + """Return the primary reader for compatibility; prefer :func:`readers_for`.""" + selected = readers_for(path, data) + return selected[0] if selected else None + + +def read_native(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[str], list[dict], list[dict], list[dict]]: + """Read one immutable source buffer with every applicable native reader.""" + reader_ids: list[str] = [] + facts: list[dict] = [] + edges: list[dict] = [] + diagnostics: list[dict] = [] + for reader_id, reader in readers_for(path, data): + if reader_id == "metadata-standards" and any(d.get("severity") == "error" for d in diagnostics): + continue + reader_ids.append(reader_id) + local_context = dict(context) + try: + if reader_id == "msdmd-ratios" and path.suffix.lower() in _TYPESCRIPT_SUFFIXES | {".rs", ".java", ".c", ".cc", ".cpp", ".cxx", ".hpp", ".hxx", ".h"}: + lines = [""] * len(data.decode("utf-8-sig").split("\n")) + for f in facts: + if f["kind"] == "comment" and f["extraction"]["reader_id"] in {"typescript-compiler", "native-grammars"}: + for offset, line in enumerate(f["native"]["value"]["text"].split("\n")): + index = f["source"]["location"]["start_line"] - 1 + offset + if index < len(lines): + lines[index] = line + local_context["comment_source"] = "\n".join(lines) + local_context["configuration_sha256"] = _digest(json.dumps({"reader_id": reader_id, "reader_version": _MANIFESTS[reader_id]["version"]}, sort_keys=True)) + reader_facts, reader_edges, reader_diagnostics = reader(path, data, local_context) + except (ImportError, FileNotFoundError) as exc: + reader_facts, reader_edges = [], [] + reader_diagnostics = [_diagnostic(local_context, reader_id=reader_id, + code="reader_dependency_unavailable", message=type(exc).__name__ + "; install declared reader dependencies", + status="unsupported")] + except Exception as exc: + # Malformed inputs do not stop independent files. Do not publish exception + # text: parser messages can contain source literals or credentials. + reader_facts, reader_edges = [], [] + reader_diagnostics = [_diagnostic(local_context, reader_id=reader_id, + code="native_reader_error", message=type(exc).__name__ + "; input rejected by " + reader_id, + status="invalid", severity="error")] + for fact in reader_facts: + fact["extraction"]["implementation_sha256"] = implementation_digest() + + facts.extend(reader_facts) + edges.extend(reader_edges) + diagnostics.extend(reader_diagnostics) + # The same complete owning tree is emitted once even when a standard adapter + # adds a more precise root classification than the generic syntax reader. + roots = [f for f in facts if f["extraction"]["reader_id"] == "metadata-standards" and f["source"]["location"] == {"pointer": ""}] + if roots: + facts = [f for f in facts if not (f["kind"] == "structured-document" and f["extraction"]["reader_id"] != "metadata-standards" + and any(f["native"]["value"] == root["native"]["value"] for root in roots))] + return reader_ids, facts, edges, diagnostics +# ratios: loc_comments=889:48 imports_exports=22:5 calls_definitions=267:28 diff --git a/msdmd/references/implemented-readers.md b/msdmd/references/implemented-readers.md new file mode 100644 index 0000000..bee2dae --- /dev/null +++ b/msdmd/references/implemented-readers.md @@ -0,0 +1,79 @@ +# Integrated native reader support + +This matrix describes shipped extraction, not certification against entire +standards. `msdmd/readers.py` owns executable selection and machine manifests; +`tests/test_native_collection.py` and `tests/test_native_standards.py` exercise +these readers through the default schema-2 collector. No MSDMD redeclaration is +required. Pin dependencies from `msdmd/requirements.txt` and `package-lock.json`. + +| Owning convention | Implemented extraction | Explicit limit | +|---|---|---| +| Python AST/tokenize, PEP 257 | Qualified symbols, signatures, decorators, structurally attached comments/docstrings, imports, literal `__all__`, SPDX headers | Running Python grammar; no target import, call graph, dynamic exports or rename inference | +| ReST/Sphinx, Google and NumPy docstrings | Structured parameters/returns/raises and descriptive fields with raw text, using docstring-parser 0.18.0 | Parser-supported dialect fields; ambiguous/custom constructs retain source and diagnostics | +| JavaScript/TypeScript/JSDoc | TypeScript 5.8.3 AST, nested declarations, multiline signatures, static imports/exports, compiler-attached repeated documentation tags, actual comments | No target config, module resolution, decorators or runtime execution; full TSDoc validation not claimed | +| Rustdoc / Java Javadoc / C and C++ Doxygen source | Pinned tree-sitter grammar declarations, lexical scope, attached raw docs and repeated tags, source attributes/imports, SPDX | Grammar subsets, not compiler semantics. Macros/conditional compilation unresolved. `.h` is ambiguous, not guessed | +| JSON / TOML | Complete typed document tree; duplicate/nonfinite JSON rejection; TOML dates/times explicitly tagged | Syntax preservation is not domain-schema validation | +| YAML / Markdown frontmatter | Maintained PyYAML syntax parser, explicit YAML 1.2 core resolution, nested/flow structures, block strings, bounded acyclic aliases; typed scalar-key maps tagged for JSON | No custom tags, cycles, merge-key dialect or complex keys; errors remain visible | +| Python / npm / Cargo manifests | Package identity, dependency classes, Cargo conditional dependencies, raw owning trees | No installation, resolution or scripts; Python imports are not calls | +| npm lockfile 2/3; Cargo/Poetry/uv locks; pnpm document | Recorded package metadata; per-package rows for supported npm and TOML lock structures | Version/dialect fields retained; pnpm semantic graph and cross-lock resolution not claimed | +| GitHub CODEOWNERS | Ordered patterns, repeated owners, ownerless exemptions, authoritative-file precedence and shadowed rules | No path matching, team permission lookup or inferred operational ownership | +| SPDX / REUSE | Actual code headers, `.license` and SPDX tag-value lines, REUSE.toml annotations; SPDX 2.2/2.3 JSON document/packages/files/relationships | Tag-value is a line subset, not complete multiline SPDX; no license-compliance conclusion | +| CITATION.cff 1.2.0 | Nested citation metadata, contributors, identifiers and unknown fields | No citation validation or DOI resolution | +| OpenAPI 3.0/3.1; Swagger 2.0 | Owning document, operations, native operation IDs, path/webhook scope and refs | No request/response validator; unknown versions retained but unresolved | +| JSON Schema drafts 4/6/7/2019-09/2020-12 | Schema document, identity, unknown keywords and unresolved references | No remote references or instance validation | +| SARIF 2.1.0 / JUnit XML | Producer-linked analysis results and reported pass/failure/error/skipped tests | Reports are reported evidence, never independent verification | +| Doxygen XML / .NET XML docs / Maven POM | Namespace-aware document tree, documented-symbol identities and dependency declarations | Producer-specific XML extras preserved; no build or complete schema validation | +| CycloneDX 1.4–1.6 JSON | BOM and nested component identities | No vulnerability conclusion; duplicate native identifiers diagnosed | +| in-toto Statement v0.1/v1 / DSSE | Statements, subjects, preserved predicates, bounded DSSE base64 decoding | Signatures explicitly unverified; no authenticated provenance claim | +| Jupyter metadata | Notebook/cell metadata and native cell IDs | Owning JSON includes other notebook content; apply disclosure policy before publication | +| Shell / systemd / Git ignore / requirements / SVG / llms.txt | Declared shebang/directives, ordered unit settings, ignore lines, requirements, XML title/description and instruction-file structure | Extraction only; no shell/systemd/browser execution or ignore-rule applicability | +| Supplemental MSDMD / RATIOS | Existing grammar, source-qualified addresses/edges, duplicate-ID diagnostics, syntax-aware comments in supported code languages | Block adoption is independent of native information coverage | + +## Coverage and acceptance + +`--require-source` rejects unmatched or incompletely extracted required sources. +`--require-fact 'GLOB::NAMESPACE::KIND'` requires named source-linked witnesses; +it does not invent obligations. Missing packages produce unsupported diagnostics. +Read errors, parse errors and identity conflicts invalidate strict output. +Other optional unknowns remain visible rather than blocking unrelated evidence. +Native fields are never forced into the schema-1 flat block map. Large generated +TypeScript fact arrays use typed chunks to bound compiler inference; the +visualizer decodes only those literal JSON chunks, never arbitrary expressions. + +No parser executes inspected programs, follows remote references, expands +macros/templates or treats source instructions as agent instructions. Structured +secrets/URL credentials are redacted and secret-named files excluded; neither +mechanism is a general secret scanner. XML excludes DTD/entities and non-UTF-8. +Resource limits are declared before extraction; all excluded scope is reported. + +## Validation + +```bash +python -m unittest tests.test_native_collection tests.test_native_standards +python -m unittest tests.test_module_projection tests.test_collect tests.test_visualize +python -m msdmd.collect --root . --repo The-Interdependency/skill-lib \ + --snapshot-identity --import-path ./msdmd/collection --out skill-lib_msdmd.ts --strict --check +node msdmd/node_modules/typescript/bin/tsc --noEmit --strict --skipLibCheck \ + --target ES2022 --module commonjs msdmd/collection.ts skill-lib_msdmd.ts +``` + +## hmmm + +A new convention requires a fixture-backed reader and declared authority/scope, +not another catalogue entry or a guessed universal mapping. Source extraction +and application semantics remain separate. Necessary additional policy includes +path applicability for ownership, cross-source semantic conflicts, build-context +resolution, arbitrary-language support and independent evidence verification. + +## Regression-qualified boundaries + +`tests/test_native_review_regressions.py` exercises these acceptance cases: + +- When a native comment parser is missing or ambiguous, block-shaped candidates survive in source-qualified diagnostics with unverified standing. They are not promoted to declarations; strict collection fails instead of silently dropping them. +- JSON numeric values outside safe integer/exact binary64 representation use `{ "$type": "json-number", "lexeme": "..." }`, preserving the original numeric lexeme across TypeScript/JavaScript. Nonfinite overflow remains rejected. This is an explicit tagged representation, not a claim that JavaScript arithmetic is exact. +- Systemd continuation backslashes become spaces and intervening comments are ignored. Environment assignments are checked individually. Plain words and whole-word quotes are supported; unimplemented escaping/quoting withholds the entire value and reports partial scope. No systemd expansion is executed. +- Requirements include/constraint directives remain source-owned records and are explicitly unresolved; required-source coverage fails until their information obligation is satisfied. +- TypeScript local export lists retain public aliases, type-only flags and source-local declaration links. Compiler/build-context resolution remains out of scope. +- Maven XML recognition requires its POM namespace or an unnamespaced project with modelVersion 4.0.0. Other project XML stays generic XML. +- SVG uses the same bounded, UTF-8, DTD/entity-rejecting parser as other XML inputs. +- Explicit YAML `!!float 1` is supported and is a regression control, not an outstanding defect. diff --git a/msdmd/references/metadata-conventions.md b/msdmd/references/metadata-conventions.md index 1a2298f..9ebe593 100644 --- a/msdmd/references/metadata-conventions.md +++ b/msdmd/references/metadata-conventions.md @@ -23,22 +23,17 @@ data without being recommended for new authoring. ## Convention catalogue -### Shipped reader status - -The catalogue is deliberately larger than the current implementation. Support -is promoted only for an executable reader and its tested subset: - -| Reader | Status | Implemented subset | Still `hmmm` | -|---|---|---|---| -| `the-interdependency.msdmd.python-ast-tokenize` 1.0.0 (`python-module-reader.json`) | partial | `.py` class/function/method identities and signatures; decorators; module/class/function docstrings; syntax-aware line-comment groups; structural attachment; source/schema/reader/manifest/runtime binding; parse and malformed-fence diagnostics | Imports and dependency edges, calls, dynamic exports, parsed Sphinx/Google/NumPy docstring fields, type-comment semantics, `.pyi` distinctions, cross-revision rename identity, full discovery ledger | -| Universal MSDMD block parsers | implemented-and-tested for block grammar only | Registered line-comment markers and supplemental fenced entries | Native declarations, syntax-aware rejection of block-shaped text inside strings, qualified edge validation | -| Every other catalogue family | specified-only unless another owning skill says otherwise | Discovery and reader requirements below | Extraction, reconciliation, and coverage support | - -The Python reader emits the separate -`urn:the-interdependency:msdmd:module-projection:1` JSONL format. That projection -is useful for per-module documentation and metadata-to-symbol assignment, but it -is not the unified native-capable repository collection described later in this -reference. +### Shipped implementation and catalogue boundary + +The integrated schema-2 implementation and fixture-backed extraction subsets are +listed in [implemented-readers.md](implemented-readers.md). `readers.py` emits its +machine manifests in every collection. The Python attachment reader is shared +with the per-module projection; it is no longer disconnected from collection. + +The families below remain a discovery catalogue, not a blanket implementation +claim. An unlisted or unsupported format remains visible as `hmmm`, and required +coverage cannot pass without a capable reader and source-linked witnesses. + ### Language, symbol, and documentation metadata diff --git a/msdmd/requirements.txt b/msdmd/requirements.txt new file mode 100644 index 0000000..2beb831 --- /dev/null +++ b/msdmd/requirements.txt @@ -0,0 +1,9 @@ +# Native reader runtime. Install before the full native-standards gate: +# python -m pip install -r msdmd/requirements.txt +PyYAML==6.0.3 +docstring-parser==0.18.0 +tree-sitter==0.26.0 +tree-sitter-rust==0.24.2 +tree-sitter-java==0.23.5 +tree-sitter-c==0.24.2 +tree-sitter-cpp==0.23.4 diff --git a/msdmd/standards.py b/msdmd/standards.py new file mode 100644 index 0000000..d021cbf --- /dev/null +++ b/msdmd/standards.py @@ -0,0 +1,284 @@ +# ratios: loc_comments=254:13 imports_exports=8:2 calls_definitions=146:5 +"""Semantic projections for native metadata documents, preserving owning trees. + +Usage: registry invokes read_standards(path, bytes, context). The JSON/YAML/TOML +syntax readers retain unknown fields; this adapter adds source-linked operations, +schemas, dependency classes, ownership, reported tests and supply-chain subjects. +These are extraction subsets, not complete schema validators or attestation +verifiers. References are retained and diagnosed; no network fetch is performed. +""" +from __future__ import annotations + +import base64 +import re +import tomllib +from pathlib import Path +from typing import Any + +from msdmd.formats import is_json_schema_uri, parse_json, parse_yaml, parse_xml + + +def pointer(*parts: Any) -> str: + return ''.join('/' + str(p).replace('~', '~0').replace('/', '~1') for p in parts) + + +def read_standards(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]: + from msdmd.readers import _fact, _diagnostic, _edge, _redact_sensitive + rid = 'metadata-standards' + facts: list = [] + edges: list = [] + diagnostics: list = [] + + def emit(convention: str, version: str, kind: str, loc: str, value: Any, + *, scope: str = 'document', identity: str | None = None, + native_id: str | None = None, standing: str = 'declared') -> dict: + value, redactions = _redact_sensitive(value) + if redactions: + diagnostics.append(_diagnostic(context, reader_id=rid, code='sensitive_fields_redacted', + message='sensitive values withheld from metadata projection', status='redacted')) + fact = _fact(dict(context, convention_version=version, dialect=convention), reader_id=rid, + convention=convention, kind=kind, scope=scope, identity=identity or context['file'], + location={'pointer': loc}, value=value, native_id=native_id, standing=standing) + facts.append(fact) + return fact + + def unsupported(code: str, message: str, *, status: str = 'unsupported') -> None: + diagnostics.append(_diagnostic(context, reader_id=rid, code=code, message=message, status=status)) + + suffix = path.suffix.lower() + if suffix == '.xml': + root = parse_xml(data) + local = lambda node: node.tag.rsplit('}', 1)[-1] + xml_redacted = False + + def scrub_xml(node: Any) -> None: + # Redact in the XML name domain, before names become generic tag/text keys. + # Scrub the parsed tree once so every later semantic projection is safe too. + nonlocal xml_redacted + if _redact_sensitive({local(node): ''})[1]: + node.text = '[redacted]' + node.attrib.clear() + node[:] = [] + xml_redacted = True + return + for name in list(node.attrib): + if _redact_sensitive({name.rsplit('}', 1)[-1]: ''})[1]: + node.set(name, '[redacted]') + xml_redacted = True + for child in node: + scrub_xml(child) + + scrub_xml(root) + if xml_redacted: + diagnostics.append(_diagnostic(context, reader_id=rid, code='sensitive_fields_redacted', + message='sensitive XML element or attribute content withheld before projection', status='redacted')) + def element_value(node: Any) -> dict: + return {'tag': node.tag, 'attributes': dict(node.attrib), 'text': node.text, + 'tail': node.tail, 'children': [element_value(child) for child in node]} + root_name = local(root) + conventions = {'testsuites': 'junit.xml', 'testsuite': 'junit.xml', + 'doxygen': 'doxygen.xml', 'doxygenindex': 'doxygen.xml', 'doc': 'dotnet.xml-doc', + 'project': 'maven.pom'} + convention = conventions.get(root_name, 'xml.document') + maven_namespace = 'http://maven.apache.org/POM/4.0.0' + maven_identity = root.tag == '{' + maven_namespace + '}project' or (root.tag == 'project' and + any(child.tag == 'modelVersion' and (child.text or '').strip() == '4.0.0' for child in root)) + if convention == 'maven.pom' and not maven_identity: + convention = 'xml.document' + emit(convention, root.get('version', 'unspecified-producer-dialect'), 'structured-document', '', element_value(root), + standing='reported-evidence' if convention == 'junit.xml' else 'declared') + def walk(node: Any, loc: str) -> None: + name = local(node) + if name == 'testcase' and convention == 'junit.xml': + children = [local(c) for c in node] + result = 'error' if 'error' in children else 'failure' if 'failure' in children else 'skipped' if 'skipped' in children else 'reported-pass' + emit(convention, 'unspecified-producer-dialect', 'test-result', loc, + {'attributes': dict(node.attrib), 'result': result, 'children': [element_value(c) for c in node]}, + scope='testcase', identity=loc, native_id=node.get('name'), standing='reported-evidence') + elif convention == 'doxygen.xml' and name in {'compounddef', 'memberdef'}: + emit(convention, root.get('version', 'hmmm'), 'documented-symbol', loc, element_value(node), + scope='symbol', identity=node.get('id', loc), native_id=node.get('id')) + elif convention == 'dotnet.xml-doc' and name == 'member': + emit(convention, 'xml-doc-member-v1', 'documented-symbol', loc, element_value(node), + scope='symbol', identity=node.get('name', loc), native_id=node.get('name')) + elif convention == 'maven.pom' and name == 'dependency': + fields = {local(c): c.text for c in node} + emit(convention, 'POM 4.0.0', 'dependency', loc, fields, scope='package', identity=fields.get('artifactId') or loc) + for index, child in enumerate(node): + walk(child, loc + pointer('children', index)) + walk(root, '') + return facts, edges, diagnostics + + if suffix in {'.spdx', '.license'}: + for index, line in enumerate(data.decode('utf-8-sig').splitlines()): + match = re.match(r'\s*(SPDX-[A-Za-z]+|SPDXVersion|PackageName|PackageVersion|Relationship|LicenseID|LicenseConcluded|LicenseDeclared):\s*(.*)', line) + if match: + fact = emit('spdx.tag-value', 'tag-value extraction', 'license-declaration', pointer('lines', index), + {'tag': match[1], 'value': match[2]}, native_id=match[1]) + fact['source']['location'] = {'start_line': index + 1, 'end_line': index + 1} + return facts, edges, diagnostics + + if suffix in {'.yaml', '.yml', '.cff'}: + value = parse_yaml(data) + elif suffix == '.toml' or path.name in {'Cargo.lock', 'poetry.lock', 'uv.lock'}: + value = tomllib.loads(data.decode('utf-8')) + else: + value = parse_json(data) + if not isinstance(value, dict): + return facts, edges, diagnostics + + # A structured-document fact is a lossless data view, not standard validation. + if 'openapi' in value or 'swagger' in value: + version = str(value.get('openapi', value.get('swagger'))) + emit('openapi.document', version, 'api-description', '', value) + if not (version == '2.0' or re.fullmatch(r'3\.[01]\.\d+', version)): + unsupported('unsupported_openapi_version', 'preserved document; operations require Swagger 2 or OpenAPI 3.0/3.1') + else: + for section in ('paths', 'webhooks'): + paths = value.get(section, {}) + if not isinstance(paths, dict): + raise ValueError('OpenAPI paths/webhooks must be a mapping') + for route, item in paths.items(): + if not isinstance(item, dict): + raise ValueError('OpenAPI path item must be a mapping') + for method, operation in item.items(): + if method not in {'get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'}: + continue + if not isinstance(operation, dict): + raise ValueError('OpenAPI operation must be a mapping') + emit('openapi.document', version, 'api-operation', pointer(section, route, method), operation, + scope='operation', identity=f'{section}:{method.upper()} {route}', native_id=operation.get('operationId')) + elif is_json_schema_uri(value.get('$schema')): + version = str(value['$schema']) + emit('json.schema', version, 'schema-description', '', value, scope='schema', native_id=value.get('$id', value.get('id'))) + if not re.fullmatch(r'https?://json-schema\.org/(?:draft/(?:2020-12|2019-09)|draft-0[467])/schema#?', version): + unsupported('unsupported_json_schema_draft', 'preserved schema; semantic extraction tested for drafts 4/6/7/2019-09/2020-12') + if 'cff-version' in value: + version = str(value['cff-version']) + emit('citation.cff', version, 'citation', '', value, scope='work', native_id=value.get('doi')) + if version != '1.2.0': + unsupported('unsupported_cff_version', 'citation fields preserved; tested CFF version is 1.2.0') + if 'runs' in value and ('sarif' in str(value.get('$schema', '')).lower() or value.get('version') == '2.1.0'): + version = str(value.get('version', 'hmmm')) + emit('sarif', version, 'analysis-report', '', value, scope='report', standing='reported-evidence') + if version != '2.1.0': + unsupported('unsupported_sarif_version', 'result mapping requires SARIF 2.1.0') + else: + for i, run in enumerate(value['runs']): + if not isinstance(run, dict): + raise ValueError('SARIF run must be a mapping') + for j, result in enumerate(run.get('results', [])): + emit('sarif', version, 'analysis-result', pointer('runs', i, 'results', j), + {'result': result, 'producer': run.get('tool'), 'invocations': run.get('invocations')}, + scope='analysis-result', identity=f'run:{i}/result:{j}', standing='reported-evidence') + if 'spdxVersion' in value: + version = str(value['spdxVersion']) + emit('spdx.json', version, 'sbom', '', value, scope='artifact', native_id=value.get('SPDXID'), standing='reported-evidence') + if version not in {'SPDX-2.2', 'SPDX-2.3'}: + unsupported('unsupported_spdx_version', 'package mapping tested for SPDX 2.2/2.3 JSON') + else: + for section in ('packages', 'files', 'relationships'): + for i, item in enumerate(value.get(section, [])): + emit('spdx.json', version, 'artifact-' + section.rstrip('s'), pointer(section, i), item, + scope='artifact', identity=item.get('SPDXID', f'{section}:{i}'), native_id=item.get('SPDXID'), standing='reported-evidence') + if value.get('bomFormat') == 'CycloneDX': + version = str(value.get('specVersion', 'hmmm')) + emit('cyclonedx.json', version, 'sbom', '', value, scope='artifact', native_id=value.get('serialNumber'), standing='reported-evidence') + if version not in {'1.4', '1.5', '1.6'}: + unsupported('unsupported_cyclonedx_version', 'component mapping tested for CycloneDX 1.4/1.5/1.6') + else: + def components(items: list, loc: str) -> None: + for index, item in enumerate(items): + where = loc + pointer(index) + emit('cyclonedx.json', version, 'artifact-component', where, item, scope='artifact', + identity=item.get('bom-ref', where), native_id=item.get('bom-ref'), standing='reported-evidence') + components(item.get('components', []), where + '/components') + components(value.get('components', []), '/components') + statement = value + statement_pointer = '' + if value.get('payloadType') == 'application/vnd.in-toto+json' and isinstance(value.get('payload'), str): + statement = parse_json(base64.b64decode(value['payload'], validate=True)) + statement_pointer = '/payload' + emit('dsse.envelope', 'v1', 'signed-envelope', '', value, scope='attestation', standing='reported-evidence') + unsupported('unverified_signature', 'envelope parsed; signature verification was not requested or performed', status='unverified') + if isinstance(statement, dict) and str(statement.get('_type', '')).startswith('https://in-toto.io/Statement/'): + version = str(statement['_type']) + fact = emit('in-toto.statement', version, 'attestation', statement_pointer, statement, scope='attestation', standing='reported-evidence') + if statement_pointer: + fact['projection'] = {'mapping_version': 'dsse-base64-json@1', 'loss': 'none; signature not verified'} + if version not in {'https://in-toto.io/Statement/v1', 'https://in-toto.io/Statement/v0.1'}: + unsupported('unsupported_statement_version', 'subject mapping requires in-toto Statement v1 or v0.1') + else: + for i, subject in enumerate(statement.get('subject', [])): + emit('in-toto.statement', version, 'attested-subject', statement_pointer + pointer('subject', i), subject, + scope='artifact', identity=subject.get('name', str(i)), native_id=subject.get('name'), standing='reported-evidence') + if path.name in {'package-lock.json', 'npm-shrinkwrap.json'}: + version = str(value.get('lockfileVersion', 'hmmm')) + emit('npm.lockfile', version, 'lockfile', '', value, scope='package') + if version not in {'2', '3'}: + unsupported('unsupported_npm_lock_version', 'resolved-package mapping requires npm lockfileVersion 2 or 3') + else: + for name, item in value.get('packages', {}).items(): + emit('npm.lockfile', version, 'locked-package', pointer('packages', name), item, + scope='package', identity=name or '.', native_id=name) + if path.name in {'Cargo.toml', 'Cargo.lock', 'poetry.lock', 'uv.lock', 'pnpm-lock.yaml'}: + convention = {'Cargo.toml': 'cargo.manifest', 'Cargo.lock': 'cargo.lockfile', + 'poetry.lock': 'poetry.lockfile', 'uv.lock': 'uv.lockfile', 'pnpm-lock.yaml': 'pnpm.lockfile'}[path.name] + version = str(value.get('version', value.get('lockfileVersion', 'source-owned-manifest'))) + emit(convention, version, 'package-metadata', '', value, scope='package') + if path.name == 'Cargo.toml': + for group in ('dependencies', 'dev-dependencies', 'build-dependencies'): + for name, requirement in value.get(group, {}).items(): + emit(convention, version, 'dependency', pointer(group, name), {'name': name, 'requirement': requirement, 'class': group}, + scope='package', identity=name, native_id=name) + for target, config in value.get('target', {}).items(): + for group in ('dependencies', 'dev-dependencies', 'build-dependencies'): + for name, requirement in config.get(group, {}).items(): + emit(convention, version, 'dependency', pointer('target', target, group, name), + {'name': name, 'requirement': requirement, 'class': group, 'condition': target}, + scope='package', identity=name, native_id=name) + elif isinstance(value.get('package'), list): + for i, package in enumerate(value['package']): + emit(convention, version, 'locked-package', pointer('package', i), package, + scope='package', identity=f"{package.get('name', '?')}@{package.get('version', '?')}", native_id=package.get('name')) + if path.name == 'REUSE.toml': + emit('reuse.toml', str(value.get('version', 'hmmm')), 'license-metadata', '', value) + for i, annotation in enumerate(value.get('annotations', [])): + emit('reuse.toml', str(value.get('version', 'hmmm')), 'license-rule', pointer('annotations', i), annotation, scope='path-rule', identity=str(i)) + if path.suffix == '.ipynb': + version = str(value.get('nbformat', 'hmmm')) + emit('jupyter.notebook', version, 'notebook-metadata', '/metadata', value.get('metadata', {})) + for i, cell in enumerate(value.get('cells', [])): + emit('jupyter.notebook', version, 'cell-metadata', pointer('cells', i, 'metadata'), cell.get('metadata', {}), scope='cell', identity=cell.get('id', str(i)), native_id=cell.get('id')) + # Reference objects are retained, never downloaded or treated as resolved. + def refs(item: Any, loc: str) -> None: + if isinstance(item, dict): + for key, child in item.items(): + child_loc = loc + pointer(key) + if key in {'$ref', '$dynamicRef'} and isinstance(child, str): + emit('metadata.reference', 'URI-reference', 'reference', child_loc, + {'uri': child, 'resolution': 'not-resolved', 'network_access': False}, standing='declared') + else: + refs(child, child_loc) + elif isinstance(item, list): + for index, child in enumerate(item): + refs(child, loc + pointer(index)) + refs(value, '') + # Native IDs have convention-owned uniqueness rules; collector pointers do + # not excuse duplicate IDs. Retain all witnesses while rejecting validity. + unique_kinds = {'openapi.document': {'api-operation'}, + 'spdx.json': {'sbom', 'artifact-package', 'artifact-file'}, + 'cyclonedx.json': {'artifact-component'}} + identities: dict[tuple[str, str], list[dict]] = {} + for fact in facts: + namespace = fact['convention']['namespace'] + native_id = fact['native']['id'] + if native_id is not None and fact['kind'] in unique_kinds.get(namespace, set()): + identities.setdefault((namespace, str(native_id)), []).append(fact) + for (namespace, _), witnesses in identities.items(): + if len(witnesses) > 1: + diagnostics.append(_diagnostic(context, reader_id=rid, + code='duplicate_native_identifier', message='duplicate native ID in ' + namespace, + status='invalid', severity='error')) + return facts, edges, diagnostics +# ratios: loc_comments=254:13 imports_exports=8:2 calls_definitions=146:5 diff --git a/msdmd/typescript-reader.cjs b/msdmd/typescript-reader.cjs new file mode 100644 index 0000000..b6a53a2 --- /dev/null +++ b/msdmd/typescript-reader.cjs @@ -0,0 +1,120 @@ +// ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm +/** Syntax-only worker. Usage: node typescript-reader.cjs < input.json + * Input: {path, text}; output: version, declarations, imports, exports, docs, + * lexically owned comments and diagnostics. No target code/config is executed. + */ +'use strict'; +const fs = require('node:fs'); +const ts = require('typescript'); +const input = JSON.parse(fs.readFileSync(0, 'utf8')); +if (typeof input.path !== 'string' || typeof input.text !== 'string') throw new Error('Invalid reader input'); +const sf = ts.createSourceFile(input.path, input.text, ts.ScriptTarget.Latest, true); +const result = {version: ts.version, declarations: [], imports: [], exports: [], docs: [], comments: [], diagnostics: []}; +const span = n => ({start_line: sf.getLineAndCharacterOfPosition(n.getStart(sf)).line + 1, + end_line: sf.getLineAndCharacterOfPosition(n.getEnd()).line + 1}); +const text = n => n ? n.getText(sf) : null; +const counts = new Map(); +const commentRanges = new Map(); +const declarationRanges = []; +const qualify = (parent, name) => parent ? `${parent}.${name}` : name; +function visit(node, owner = '') { + if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) { + if (node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) { + result.imports.push({module: node.moduleSpecifier.text, kind: ts.isImportDeclaration(node) ? 'import' : 'reexport', + declaration: text(node), owner, ...span(node)}); + } else if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) { + for (const item of node.exportClause.elements) { + result.exports.push({kind: 'local-export', local_name: (item.propertyName || item.name).text, + exported_name: item.name.text, type_only: !!node.isTypeOnly || !!item.isTypeOnly, + declaration: text(node), owner, ...span(item)}); + } + } + } + if (ts.isExportAssignment(node)) { + let expression = node.expression; + while (ts.isParenthesizedExpression(expression)) expression = expression.expression; + result.exports.push({kind: 'export-assignment', + local_name: ts.isIdentifier(expression) ? expression.text : null, + exported_name: node.isExportEquals ? 'export=' : 'default', type_only: false, + expression: text(node.expression), declaration: text(node), owner, ...span(node)}); + } + if (ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword || + (ts.isIdentifier(node.expression) && node.expression.text === 'require'))) { + result.diagnostics.push({code: 'dynamic_module_loading', status: 'dynamic-unresolved', ...span(node)}); + } + let localOwner = owner; + const defaultModifier = !!node.modifiers?.some(m => m.kind === ts.SyntaxKind.DefaultKeyword); + let name = node.name && (ts.isIdentifier(node.name) || ts.isStringLiteralLike(node.name)) ? node.name.text : null; + const anonymousDefault = !name && defaultModifier && (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)); + if (anonymousDefault) name = '$default'; // Collector identity, explicitly not a source name. + const kind = ts.SyntaxKind[node.kind]; + const isDecl = name && (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || + ts.isTypeAliasDeclaration(node) || ts.isMethodDeclaration(node) || ts.isMethodSignature(node) || + ts.isPropertyDeclaration(node) || ts.isPropertySignature(node) || ts.isVariableDeclaration(node) || + ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)); + if (isDecl) { + localOwner = qualify(owner, name); + const ordinal = counts.get(localOwner) || 0; counts.set(localOwner, ordinal + 1); + const identity = `${localOwner}#${ordinal}`; + let carrier = node; + if (ts.isVariableDeclaration(node)) carrier = node.parent.parent; + const exported = !!carrier.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword); + const declaration = {name: anonymousDefault ? null : name, qualified_name: localOwner, identity, kind, exported, + anonymous: anonymousDefault, ...span(node), + parameters: node.parameters?.map(p => ({name: text(p.name), type: text(p.type), optional: !!p.questionToken, + rest: !!p.dotDotDotToken, default: text(p.initializer)})) || [], + returns: text(node.type), decorators: (ts.canHaveDecorators(node) ? ts.getDecorators(node) : [])?.map(text) || []}; + result.declarations.push(declaration); + declarationRanges.push({start: node.getStart(sf), end: node.getEnd(), identity, owner: localOwner}); + if (defaultModifier) { + result.exports.push({kind: 'default-declaration', local_name: anonymousDefault ? null : name, + exported_name: 'default', type_only: false, declaration: text(node), owner, + declaration_identities: [identity], ...span(node)}); + } + for (const doc of carrier.jsDoc || []) { + result.docs.push({identity, owner: localOwner, ...span(doc), text: text(doc), + description: typeof doc.comment === 'string' ? doc.comment : (doc.comment || []).map(c => c.text || '').join(''), + tags: (doc.tags || []).map(t => ({tag: t.tagName.text, text: text(t), name: text(t.name), + type: text(t.typeExpression), comment: typeof t.comment === 'string' ? t.comment : null}))}); + } + } + ts.forEachChild(node, child => visit(child, localOwner)); +} +visit(sf); +// Token traversal includes trivia before closing braces (even empty bodies). +// Compiler token boundaries avoid treating strings/templates/regexes as comments. +function collectComments(node) { + for (const range of [...(ts.getLeadingCommentRanges(input.text, node.getFullStart()) || []), + ...(ts.getTrailingCommentRanges(input.text, node.getEnd()) || [])]) { + commentRanges.set(range.pos, range); + } + for (const child of node.getChildren(sf)) collectComments(child); +} +collectComments(sf); +for (const range of [...commentRanges.values()].sort((a, b) => a.pos - b.pos)) { + const owners = declarationRanges.filter(d => d.start <= range.pos && range.end <= d.end); + owners.sort((a, b) => (a.end - a.start) - (b.end - b.start)); + const owner = owners[0]; + result.comments.push({text: input.text.slice(range.pos, range.end), + start_line: sf.getLineAndCharacterOfPosition(range.pos).line + 1, + end_line: sf.getLineAndCharacterOfPosition(range.end).line + 1, + identity: owner?.identity || null, owner: owner?.owner || null, + attachment: owner ? 'lexically-enclosing-symbol' : 'module-trivia'}); +} +for (const binding of result.exports) { + const qualified = binding.local_name === null ? null : qualify(binding.owner, binding.local_name); + const declarations = binding.declaration_identities + ? result.declarations.filter(item => binding.declaration_identities.includes(item.identity)) + : result.declarations.filter(item => qualified !== null && item.qualified_name === qualified); + binding.declaration_identities = declarations.map(item => item.identity); + for (const declaration of declarations) { + declaration.exported = true; + declaration.export_names = [...new Set([...(declaration.export_names || []), binding.exported_name])]; + } +} +for (const d of sf.parseDiagnostics) result.diagnostics.push({code: `typescript_${d.code}`, status: 'invalid', + message: ts.flattenDiagnosticMessageText(d.messageText, '\n'), + start_line: sf.getLineAndCharacterOfPosition(d.start || 0).line + 1, + end_line: sf.getLineAndCharacterOfPosition((d.start || 0) + (d.length || 0)).line + 1}); +process.stdout.write(JSON.stringify(result)); +// ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm diff --git a/msdmd/visualize.py b/msdmd/visualize.py index 7b3665f..98b8092 100644 --- a/msdmd/visualize.py +++ b/msdmd/visualize.py @@ -1,4 +1,4 @@ -# ratios: loc_comments=167:13 imports_exports=5:3 calls_definitions=70:8 +# ratios: loc_comments=231:15 imports_exports=6:3 calls_definitions=104:9 """Render an msdmd collection as a small Mermaid relationship graph. The input may be raw JSON, the generated TypeScript shape emitted by @@ -11,13 +11,16 @@ from __future__ import annotations import argparse +import hashlib import json import re from pathlib import Path _SAFE_NODE_RE = re.compile(r"[^A-Za-z0-9_]") _IDENT_RE = re.compile(r"[A-Za-z_$][A-Za-z0-9_$]*") -_CALL_MARKER = "defineMsdmdCollection(" +_COLLECTION_CALL_RE = re.compile( + r"export\s+default\s+(?:defineMsdmdCollectionV2|defineMsdmdCollection)\s*\(" +) def _strip_comments(text: str) -> str: @@ -57,10 +60,10 @@ def _strip_comments(text: str) -> str: def _extract_payload(text: str, path: Path) -> str: """Return the argument of ``defineMsdmdCollection(...)`` in ``text``.""" - start = text.find(_CALL_MARKER) - if start < 0: + match = _COLLECTION_CALL_RE.search(text) + if match is None: raise ValueError(f"{path} is not JSON or a defineMsdmdCollection TypeScript collection point") - i = start + len(_CALL_MARKER) + i = match.end() depth, j, quote = 1, i, "" while j < len(text): ch = text[j] @@ -132,13 +135,57 @@ def _object_literal_to_json(text: str) -> str: return "".join(out) +def _expand_fact_chunks(text: str) -> str: + """Decode only the generator's literal JSON chunks; never evaluate JS.""" + token = "mergeMsdmdFactChunks(" + decoder = json.JSONDecoder() + out: list[str] = [] + i = 0 + while i < len(text): + if text[i] in "\"'": + quote, start = text[i], i + i += 1 + while i < len(text): + if text[i] == "\\": + i += 2 + continue + if text[i] == quote: + i += 1 + break + i += 1 + out.append(text[start:i]) + elif text.startswith(token, i): + i += len(token) + facts: list[dict] = [] + while True: + while i < len(text) and text[i].isspace(): + i += 1 + chunk, i = decoder.raw_decode(text, i) + if not isinstance(chunk, list) or not all(isinstance(v, dict) for v in chunk): + raise ValueError("fact chunks must be literal JSON object arrays") + facts.extend(chunk) + while i < len(text) and text[i].isspace(): + i += 1 + if i < len(text) and text[i] == ")": + i += 1 + break + if i >= len(text) or text[i] != ",": + raise ValueError("unterminated fact chunks") + i += 1 + out.append(json.dumps(facts, ensure_ascii=False)) + else: + out.append(text[i]) + i += 1 + return "".join(out) + + def load_collection(path: Path) -> dict: """Load a collection from JSON, generated, or hand-authored TypeScript.""" text = _strip_comments(path.read_text(encoding="utf-8")).strip() if text.startswith("{"): return json.loads(text) - payload = _extract_payload(text, path) + payload = _expand_fact_chunks(_extract_payload(text, path)) try: return json.loads(payload) except json.JSONDecodeError: @@ -146,8 +193,9 @@ def load_collection(path: Path) -> dict: def _node_id(value: str) -> str: - normalized = _SAFE_NODE_RE.sub("_", value).strip("_") - return normalized or "hmmm" + """Return a collision-resistant Mermaid id for a qualified address.""" + normalized = _SAFE_NODE_RE.sub("_", value).strip("_")[:32] or "hmmm" + return f"{normalized}_{hashlib.sha256(value.encode('utf-8')).hexdigest()[:12]}" def _label(value: str) -> str: @@ -155,28 +203,42 @@ def _label(value: str) -> str: def render_mermaid(collection: dict) -> str: - """Render ``collection`` as Mermaid flowchart text.""" + """Render schema-1 or schema-2 ``collection`` as Mermaid flowchart text.""" lines = ["flowchart TD"] repo = collection.get("repo", "repo") - lines.append(f' repo["{_label(str(repo))}"]') + repo_node = _node_id(f"repository:{repo}") + lines.append(f' {repo_node}["{_label(str(repo))}"]') - emitted_nodes = {"repo"} + emitted_nodes = {repo_node} + labels: dict[str, str] = {} for declaration in collection.get("declarations", []): - node = _node_id(str(declaration["id"])) + address = str(declaration.get("address", declaration["id"])) + node = _node_id(address) label = f'{declaration["id"]}\\n{declaration["block"]}\\n{declaration["file"]}' + labels[address] = label if node not in emitted_nodes: lines.append(f' {node}["{_label(label)}"]') - lines.append(f" repo --> {node}") + lines.append(f" {repo_node} --> {node}") emitted_nodes.add(node) + for fact in collection.get("facts", []): + subject = fact.get("subject", {}) + address = str(subject.get("address", fact.get("address", "hmmm"))) + labels.setdefault( + address, + f'{subject.get("identity", "hmmm")}\\n{subject.get("scope", fact.get("kind", "native"))}\\n{fact.get("source", {}).get("file", "hmmm")}', + ) + for edge in collection.get("edges", []): - source = _node_id(str(edge["from"])) - target = _node_id(str(edge["to"])) + source_address = str(edge["from"]) + target_address = str(edge["to"]) + source = _node_id(source_address) + target = _node_id(target_address) if source not in emitted_nodes: - lines.append(f' {source}["{_label(str(edge["from"]))}"]') + lines.append(f' {source}["{_label(labels.get(source_address, source_address))}"]') emitted_nodes.add(source) if target not in emitted_nodes: - lines.append(f' {target}["{_label(str(edge["to"]))}"]') + lines.append(f' {target}["{_label(labels.get(target_address, target_address))}"]') emitted_nodes.add(target) lines.append(f' {source} -- "{_label(str(edge["kind"]))}" --> {target}') @@ -185,7 +247,15 @@ def render_mermaid(collection: dict) -> str: missing = ", ".join(gap.get("missing", [])) label = f'{gap.get("file", "hmmm")}\\nmissing: {missing or "hmmm"}' lines.append(f' {node}[["{_label(label)}"]]') - lines.append(f" repo -. gap .-> {node}") + lines.append(f" {repo_node} -. gap .-> {node}") + + for index, diagnostic in enumerate(collection.get("diagnostics", []), start=1): + if diagnostic.get("severity") != "error": + continue + node = f"diagnostic_{index}" + label = f'{diagnostic.get("code", "hmmm")}\\n{diagnostic.get("status", "hmmm")}' + lines.append(f' {node}{{"{_label(label)}"}}') + lines.append(f" {repo_node} -. diagnostic .-> {node}") return "\n".join(lines) + "\n" @@ -206,4 +276,4 @@ def main() -> int: if __name__ == "__main__": raise SystemExit(main()) -# ratios: loc_comments=167:13 imports_exports=5:3 calls_definitions=70:8 +# ratios: loc_comments=231:15 imports_exports=6:3 calls_definitions=104:9 diff --git a/owner-build/SKILL.md b/owner-build/SKILL.md index c6e7b5e..2ed95d0 100644 --- a/owner-build/SKILL.md +++ b/owner-build/SKILL.md @@ -10,8 +10,9 @@ who is responsible for a module from the source that owns that responsibility, so agents do not invent authority or edit sensitive code without a review path. Implementation status: this skill defines the `OWNERS` block and runner -contract. This repo does not currently ship an OWNERS runner script or native -ownership reader; consuming repos implement and test the applicable mappings. +contract. The MSDMD schema-2 collector ships ordered GitHub CODEOWNERS rule +extraction as review assignment only, but no path-applicability or operational- +ownership policy runner. Consuming repos implement and test those mappings. Read `msdmd/SKILL.md` first. Its provenance, information-coverage, parser and explicit reader-support contracts apply. @@ -29,8 +30,7 @@ must be explicit in the consuming policy, not guessed by the reader. A native declaration needs no duplicate OWNERS block. Unsupported matching, unresolved teams and conflicting assignments remain `PENDING` / `hmmm`, not proof that a module is unowned. Missing-information findings require completed -eligible-source inspection with capable readers. No native reader is supplied -by this skill text. +eligible-source inspection with capable readers. ## The block @@ -119,6 +119,6 @@ missing-owner, unsupported-rule, conflict and strict-mode fixtures. - Guessing a team from a filename. Unknown is `hmmm`. hmmm -- native provider-specific ownership readers remain consuming-repo work +- non-GitHub provider ownership readers remain consuming-repo work - whether strict policy requires operational owners for all modules or only public/sensitive ones - how to represent temporary stewardship during incidents diff --git a/skill-lib_msdmd.ts b/skill-lib_msdmd.ts index dfed685..609412f 100644 --- a/skill-lib_msdmd.ts +++ b/skill-lib_msdmd.ts @@ -1,8 +1,47 @@ -import { defineMsdmdCollection } from "./msdmd/collection"; +import { defineMsdmdCollectionV2, mergeMsdmdFactChunks } from "./msdmd/collection"; -export default defineMsdmdCollection({ +export default defineMsdmdCollectionV2({ + "capabilities": [ + "native-facts", + "supplemental-msdmd-blocks", + "source-qualified-identities", + "duplicate-id-diagnostics", + "discovery-accounting" + ], + "conflicts": [], + "coverage": { + "block_adoption": { + "BOUNDARIES": 2, + "CAPABILITIES": 2, + "CHECKS": 7, + "CONTRACTS": 9, + "DEPENDENCIES": 0, + "DOCS": 1, + "FRONTEND_META": 0, + "LLMS": 1, + "MODULE_BUILD": 18, + "OWNERS": 0 + }, + "denominator": { + "count": 231, + "kind": "discovered-files" + }, + "excluded_files": 0, + "excluded_subtrees": 13, + "information_availability": "not-evaluated-without-obligation-policy", + "invalid_files": 0, + "native_facts": 2825, + "partial_files": 2, + "required_sources": [], + "supplemental_declarations": 98, + "supported_files": 229, + "unreadable_files": 0, + "unsupported_files": 0, + "verified_behavior": "not-evaluated" + }, "declarations": [ { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#block/MODULE_BUILD/interdependent_work_graph_portfolio_plan", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -22,64 +61,180 @@ export default defineMsdmdCollection({ "user_data_boundary": "none" }, "file": "interdependent-work-graph/portfolio_plan.py", - "id": "interdependent_work_graph_portfolio_plan" + "id": "interdependent_work_graph_portfolio_plan", + "origin": "msdmd-block", + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "pointer": "block:MODULE_BUILD/id:interdependent_work_graph_portfolio_plan" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#block/LLMS/architecture_summary", "block": "LLMS", "fields": { "content": "- Skills live as root directories with SKILL.md files and optional helpers." }, "file": "llms/metadata.py", - "id": "architecture_summary" + "id": "architecture_summary", + "origin": "msdmd-block", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "pointer": "block:LLMS/id:architecture_summary" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#block/LLMS/key_definitions", "block": "LLMS", "fields": { - "msdmd": "Module Self-Declared Metadata in Markdown \u2014 native-first collection of existing code, documentation, manifest, schema, tooling and evidence metadata; MSDMD blocks supply otherwise unexpressed information. The collector remains block-only; a separate partial Python reader projects symbols, docstrings and structurally attached comments." + "msdmd": "Module Self-Declared Metadata in Markdown — native-first collection of existing code, documentation, manifest, schema, tooling and evidence metadata; MSDMD blocks supply otherwise unexpressed information. The schema-2 collector integrates native source and document readers with qualified provenance, structured docstrings, shared Python comment attachment and required-fact policies; unsupported scope remains explicit." }, "file": "llms/metadata.py", - "id": "key_definitions" + "id": "key_definitions", + "origin": "msdmd-block", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "pointer": "block:LLMS/id:key_definitions" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#block/LLMS/project_overview", "block": "LLMS", "fields": { "content": "skill-lib is the canonical organization-wide source for reusable agent skills in The Interdependency." }, "file": "llms/metadata.py", - "id": "project_overview" + "id": "project_overview", + "origin": "msdmd-block", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "pointer": "block:LLMS/id:project_overview" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#block/LLMS/usage_rules", "block": "LLMS", "fields": { "content": "- Read AGENTS.md, skills.json, and the relevant skill file before changing a skill." }, "file": "llms/metadata.py", - "id": "usage_rules" + "id": "usage_rules", + "origin": "msdmd-block", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "pointer": "block:LLMS/id:usage_rules" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#block/CAPABILITIES/repo_collection_generator", "block": "CAPABILITIES", "fields": { - "exposes": "collect, render_typescript", - "limitations": "Native files outside COMMENT_MARKERS are uncollected; skip paths and read errors are not inventoried; matching blocks in strings and test fixtures can be collected. Empty gaps without expected_blocks is not complete coverage.", - "native_ingestion": "contract", - "runner_scope": "msdmd-blocks-only", - "summary": "Generates block-only TypeScript collections from lexical source blocks using the canonical parser; not native discovery or identity validation.", - "unresolved": "hmmm: native readers, qualified edge identities, duplicate-ID validation, native-capable schema migration, and executable native acceptance fixtures remain separate implementation work." + "exposes": "collect, render_typescript, collection_errors", + "limitations": "Supported features and versions are reader-qualified; declarations and parsed reports do not prove runtime behavior. Required-source policy detects incomplete extraction.", + "native_ingestion": "implemented-tested-subsets", + "runner_scope": "native-and-supplemental-blocks", + "summary": "Produces schema-2 collections from registered native readers and supplemental blocks without executing inspected sources." }, "file": "msdmd/collect.py", - "id": "repo_collection_generator" + "id": "repo_collection_generator", + "origin": "msdmd-block", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "pointer": "block:CAPABILITIES/id:repo_collection_generator" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#block/DOCS/msdmd_foundational_contract", "block": "DOCS", "fields": { "catalogue": "msdmd/references/metadata-conventions.md", "source": "msdmd/SKILL.md", - "summary": "Native-first metadata and information-coverage contract; supplemental blocks express otherwise unexpressed information. This source link is not native extraction of the skill or catalogue." + "summary": "Native-first metadata collection with source-qualified facts, diagnostics, and coverage policy. Supplemental blocks express otherwise unexpressed information." + }, + "file": "msdmd/collect.py", + "id": "msdmd_foundational_contract", + "origin": "msdmd-block", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "pointer": "block:DOCS/id:msdmd_foundational_contract" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#block/MODULE_BUILD/msdmd_collection_generator", + "block": "MODULE_BUILD", + "fields": { + "admin_only": "false", + "auth_boundary": "none", + "internal_surface": "bounded discovery, block identity validation, edge reconciliation, coverage accounting", + "module_kind": "instrument", + "module_name": "collect", + "network_boundary": "none", + "owner": "The Interdependency skill-lib", + "public_surface": "collect, collect_legacy, collection_errors, render_typescript", + "rollback": "use --legacy-blocks-only while preserving schema incompatibility visibility", + "rollout": "schema 2 is the default CLI output; --legacy-blocks-only keeps explicit schema 1 compatibility", + "storage_boundary": "read", + "summary": "produces versioned native-first MSDMD collections without executing inspected sources", + "tests": "tests/test_collect.py, tests/test_native_collection.py", + "user_data_boundary": "read" }, "file": "msdmd/collect.py", - "id": "msdmd_foundational_contract" + "id": "msdmd_collection_generator", + "origin": "msdmd-block", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "pointer": "block:MODULE_BUILD/id:msdmd_collection_generator" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CAPABILITIES/python_module_metadata_projection", "block": "CAPABILITIES", "fields": { "exposes": "deterministic JSONL projection, Python symbol identities, native docstrings, structurally attached comments, freshness key", @@ -87,9 +242,21 @@ export default defineMsdmdCollection({ "summary": "creates one generated metadata sidecar per Python module while keeping source locations navigational rather than identity-bearing" }, "file": "msdmd/module_projection.py", - "id": "python_module_metadata_projection" + "id": "python_module_metadata_projection", + "origin": "msdmd-block", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "pointer": "block:CAPABILITIES/id:python_module_metadata_projection" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CONTRACTS/module_projection_freshness_binds_source_and_reader", "block": "CONTRACTS", "fields": { "class": "provenance", @@ -97,9 +264,21 @@ export default defineMsdmdCollection({ "then": "the deterministic projection freshness key changes" }, "file": "msdmd/module_projection.py", - "id": "module_projection_freshness_binds_source_and_reader" + "id": "module_projection_freshness_binds_source_and_reader", + "origin": "msdmd-block", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "pointer": "block:CONTRACTS/id:module_projection_freshness_binds_source_and_reader" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CONTRACTS/module_projection_line_shift_stability", "block": "CONTRACTS", "fields": { "class": "identity", @@ -107,9 +286,21 @@ export default defineMsdmdCollection({ "then": "metadata remains attached to the same qualified symbol identity after regeneration" }, "file": "msdmd/module_projection.py", - "id": "module_projection_line_shift_stability" + "id": "module_projection_line_shift_stability", + "origin": "msdmd-block", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "pointer": "block:CONTRACTS/id:module_projection_line_shift_stability" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CONTRACTS/module_projection_never_executes_source", "block": "CONTRACTS", "fields": { "class": "safety", @@ -117,9 +308,21 @@ export default defineMsdmdCollection({ "then": "projection parses bytes without importing or executing the inspected module" }, "file": "msdmd/module_projection.py", - "id": "module_projection_never_executes_source" + "id": "module_projection_never_executes_source", + "origin": "msdmd-block", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "pointer": "block:CONTRACTS/id:module_projection_never_executes_source" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/MODULE_BUILD/msdmd_python_module_projection", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -138,9 +341,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "read" }, "file": "msdmd/module_projection.py", - "id": "msdmd_python_module_projection" + "id": "msdmd_python_module_projection", + "origin": "msdmd-block", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "pointer": "block:MODULE_BUILD/id:msdmd_python_module_projection" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#block/CONTRACTS/msdmd_python_parser_preserves_field_names", "block": "CONTRACTS", "fields": { "class": "evidence", @@ -148,9 +363,21 @@ export default defineMsdmdCollection({ "then": "parsed entries retain those field names and string values without executing the inspected source" }, "file": "msdmd/parsers/universal.py", - "id": "msdmd_python_parser_preserves_field_names" + "id": "msdmd_python_parser_preserves_field_names", + "origin": "msdmd-block", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "pointer": "block:CONTRACTS/id:msdmd_python_parser_preserves_field_names" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#block/MODULE_BUILD/msdmd_python_reference_parser", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -169,9 +396,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "read" }, "file": "msdmd/parsers/universal.py", - "id": "msdmd_python_reference_parser" + "id": "msdmd_python_reference_parser", + "origin": "msdmd-block", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "pointer": "block:MODULE_BUILD/id:msdmd_python_reference_parser" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#block/CONTRACTS/msdmd_typescript_parser_preserves_field_names", "block": "CONTRACTS", "fields": { "class": "evidence", @@ -179,9 +418,21 @@ export default defineMsdmdCollection({ "then": "parsed entries retain those field names and string values without executing the inspected source" }, "file": "msdmd/parsers/universal.ts", - "id": "msdmd_typescript_parser_preserves_field_names" + "id": "msdmd_typescript_parser_preserves_field_names", + "origin": "msdmd-block", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "pointer": "block:CONTRACTS/id:msdmd_typescript_parser_preserves_field_names" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#block/MODULE_BUILD/msdmd_typescript_reference_parser", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -200,9 +451,54 @@ export default defineMsdmdCollection({ "user_data_boundary": "read" }, "file": "msdmd/parsers/universal.ts", - "id": "msdmd_typescript_reference_parser" + "id": "msdmd_typescript_reference_parser", + "origin": "msdmd-block", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "pointer": "block:MODULE_BUILD/id:msdmd_typescript_reference_parser" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#block/MODULE_BUILD/msdmd_native_reader_registry", + "block": "MODULE_BUILD", + "fields": { + "admin_only": "false", + "auth_boundary": "none", + "internal_surface": "convention-specific pure readers and source-qualified fact helpers", + "module_kind": "instrument", + "module_name": "readers", + "network_boundary": "none", + "owner": "The Interdependency skill-lib", + "public_surface": "READER_MANIFESTS, readers_for, reader_for, read_native", + "rollback": "retain schema 1 block-only consumers while removing the schema 2 runner claim", + "rollout": "enable through msdmd.collect schema 2 collections", + "storage_boundary": "read", + "summary": "statically extracts supported native metadata conventions into provenance-bearing MSDMD facts", + "tests": "tests/test_native_collection.py", + "user_data_boundary": "read" + }, + "file": "msdmd/readers.py", + "id": "msdmd_native_reader_registry", + "origin": "msdmd-block", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "pointer": "block:MODULE_BUILD/id:msdmd_native_reader_registry" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#block/MODULE_BUILD/ratios_harmonic_math", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -221,9 +517,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "none" }, "file": "ratios/harmonic_math.py", - "id": "ratios_harmonic_math" + "id": "ratios_harmonic_math", + "origin": "msdmd-block", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "pointer": "block:MODULE_BUILD/id:ratios_harmonic_math" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#block/MODULE_BUILD/ratios_harmonic_explorer", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -243,9 +551,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "none" }, "file": "ratios/harmonics.py", - "id": "ratios_harmonic_explorer" + "id": "ratios_harmonic_explorer", + "origin": "msdmd-block", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "pointer": "block:MODULE_BUILD/id:ratios_harmonic_explorer" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_clear_is_empty_commit", "block": "CONTRACTS", "fields": { "class": "doctrine", @@ -253,9 +573,21 @@ export default defineMsdmdCollection({ "then": "refused on dirty tree; on clean tree produces a commit touching zero files, carrying scar trailers, and deletes the scar" }, "file": "skill_lib/safety/repo_loto.py", - "id": "loto_clear_is_empty_commit" + "id": "loto_clear_is_empty_commit", + "origin": "msdmd-block", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "pointer": "block:CONTRACTS/id:loto_clear_is_empty_commit" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_close_deletes_tag", "block": "CONTRACTS", "fields": { "class": "doctrine", @@ -263,9 +595,21 @@ export default defineMsdmdCollection({ "then": ".loto/ is empty and HEAD carries Loto-* trailers; git is the only archive" }, "file": "skill_lib/safety/repo_loto.py", - "id": "loto_close_deletes_tag" + "id": "loto_close_deletes_tag", + "origin": "msdmd-block", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "pointer": "block:CONTRACTS/id:loto_close_deletes_tag" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_latest_test_wins", "block": "CONTRACTS", "fields": { "class": "evidence", @@ -273,9 +617,21 @@ export default defineMsdmdCollection({ "then": "close proceeds; a distinct command whose latest run failed still blocks close" }, "file": "skill_lib/safety/repo_loto.py", - "id": "loto_latest_test_wins" + "id": "loto_latest_test_wins", + "origin": "msdmd-block", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "pointer": "block:CONTRACTS/id:loto_latest_test_wins" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_one_commit_per_session", "block": "CONTRACTS", "fields": { "class": "doctrine", @@ -283,9 +639,21 @@ export default defineMsdmdCollection({ "then": "close refuses (v0.1 invariant: one session, one mutation commit)" }, "file": "skill_lib/safety/repo_loto.py", - "id": "loto_one_commit_per_session" + "id": "loto_one_commit_per_session", + "origin": "msdmd-block", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "pointer": "block:CONTRACTS/id:loto_one_commit_per_session" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_open_never_dirties", "block": "CONTRACTS", "fields": { "class": "doctrine", @@ -293,9 +661,21 @@ export default defineMsdmdCollection({ "then": "working tree is still clean; exclusion went to .git/info/exclude, never .gitignore" }, "file": "skill_lib/safety/repo_loto.py", - "id": "loto_open_never_dirties" + "id": "loto_open_never_dirties", + "origin": "msdmd-block", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "pointer": "block:CONTRACTS/id:loto_open_never_dirties" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_scar_blocks_work", "block": "CONTRACTS", "fields": { "class": "safety", @@ -303,9 +683,21 @@ export default defineMsdmdCollection({ "then": "`loto open` refuses and `loto guard` exits nonzero" }, "file": "skill_lib/safety/repo_loto.py", - "id": "loto_scar_blocks_work" + "id": "loto_scar_blocks_work", + "origin": "msdmd-block", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "pointer": "block:CONTRACTS/id:loto_scar_blocks_work" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_scope_enforced", "block": "CONTRACTS", "fields": { "class": "safety", @@ -313,9 +705,21 @@ export default defineMsdmdCollection({ "then": "close refuses with the violating paths named" }, "file": "skill_lib/safety/repo_loto.py", - "id": "loto_scope_enforced" + "id": "loto_scope_enforced", + "origin": "msdmd-block", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "pointer": "block:CONTRACTS/id:loto_scope_enforced" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/MODULE_BUILD/repo_mutation_gate", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -335,35 +739,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "none" }, "file": "skill_lib/safety/repo_loto.py", - "id": "repo_mutation_gate" - }, - { - "block": "DOCS", - "fields": { - "source": "docs/module.md", - "status": "current", - "summary": "module docs" - }, - "file": "tests/test_collect.py", - "id": "module_docs" - }, - { - "block": "LLMS", - "fields": { - "content": "example only" - }, - "file": "tests/test_llms_build.py", - "id": "project_overview" - }, - { - "block": "LLMS", - "fields": { - "content": "real declaration" + "id": "repo_mutation_gate", + "origin": "msdmd-block", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "pointer": "block:MODULE_BUILD/id:repo_mutation_gate" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" }, - "file": "tests/test_llms_build.py", - "id": "project_overview" + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_freshness_binds_source_and_reader", "block": "CHECKS", "fields": { "call": "self::test_freshness_key_changes_with_source_or_reader", @@ -374,9 +764,21 @@ export default defineMsdmdCollection({ "timeout": "10" }, "file": "tests/test_module_projection.py", - "id": "check_module_projection_freshness_binds_source_and_reader" + "id": "check_module_projection_freshness_binds_source_and_reader", + "origin": "msdmd-block", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "pointer": "block:CHECKS/id:check_module_projection_freshness_binds_source_and_reader" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_line_shift_stability", "block": "CHECKS", "fields": { "call": "self::test_line_insertions_preserve_symbol_identity_and_attachment", @@ -387,9 +789,21 @@ export default defineMsdmdCollection({ "timeout": "10" }, "file": "tests/test_module_projection.py", - "id": "check_module_projection_line_shift_stability" + "id": "check_module_projection_line_shift_stability", + "origin": "msdmd-block", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "pointer": "block:CHECKS/id:check_module_projection_line_shift_stability" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_never_executes_source", "block": "CHECKS", "fields": { "call": "self::test_projection_does_not_execute_inspected_source", @@ -400,17 +814,21 @@ export default defineMsdmdCollection({ "timeout": "10" }, "file": "tests/test_module_projection.py", - "id": "check_module_projection_never_executes_source" - }, - { - "block": "DOCS", - "fields": { - "summary": "module documentation" + "id": "check_module_projection_never_executes_source", + "origin": "msdmd-block", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "pointer": "block:CHECKS/id:check_module_projection_never_executes_source" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" }, - "file": "tests/test_module_projection.py", - "id": "module_docs" + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_oddities_visible", "block": "CHECKS", "fields": { "call": "self::test_ratio_report_lists_low_coverage_oddity", @@ -421,9 +839,21 @@ export default defineMsdmdCollection({ "timeout": "5" }, "file": "tests/test_org_reports.py", - "id": "check_org_ratio_oddities_visible" + "id": "check_org_ratio_oddities_visible", + "origin": "msdmd-block", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "pointer": "block:CHECKS/id:check_org_ratio_oddities_visible" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_skips_vendored_skills", "block": "CHECKS", "fields": { "call": "self::test_ratio_metrics_skip_vendored_agents", @@ -434,9 +864,21 @@ export default defineMsdmdCollection({ "timeout": "5" }, "file": "tests/test_org_reports.py", - "id": "check_org_ratio_skips_vendored_skills" + "id": "check_org_ratio_skips_vendored_skills", + "origin": "msdmd-block", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "pointer": "block:CHECKS/id:check_org_ratio_skips_vendored_skills" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_append_only", "block": "CHECKS", "fields": { "call": "self::test_aggregate_append_preserves_existing_content", @@ -447,9 +889,21 @@ export default defineMsdmdCollection({ "timeout": "5" }, "file": "tests/test_org_reports.py", - "id": "check_org_rec_append_only" + "id": "check_org_rec_append_only", + "origin": "msdmd-block", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "pointer": "block:CHECKS/id:check_org_rec_append_only" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_missing_repo_visible", "block": "CHECKS", "fields": { "call": "self::test_aggregate_lists_missing_rec_files", @@ -460,9 +914,21 @@ export default defineMsdmdCollection({ "timeout": "5" }, "file": "tests/test_org_reports.py", - "id": "check_org_rec_missing_repo_visible" + "id": "check_org_rec_missing_repo_visible", + "origin": "msdmd-block", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "pointer": "block:CHECKS/id:check_org_rec_missing_repo_visible" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_remaining_fallback", "block": "CHECKS", "fields": { "call": "self::test_aggregate_uses_remaining_when_latest_block_has_no_recommendations", @@ -473,9 +939,21 @@ export default defineMsdmdCollection({ "timeout": "5" }, "file": "tests/test_org_reports.py", - "id": "check_org_rec_remaining_fallback" + "id": "check_org_rec_remaining_fallback", + "origin": "msdmd-block", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "pointer": "block:CHECKS/id:check_org_rec_remaining_fallback" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_clear_is_empty_commit", "block": "CHECKS", "fields": { "call": "self::test_clear_is_empty_commit", @@ -486,9 +964,21 @@ export default defineMsdmdCollection({ "timeout": "20" }, "file": "tests/test_repo_loto.py", - "id": "check_clear_is_empty_commit" + "id": "check_clear_is_empty_commit", + "origin": "msdmd-block", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "pointer": "block:CHECKS/id:check_clear_is_empty_commit" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_close_deletes_tag", "block": "CHECKS", "fields": { "call": "self::test_close_deletes_tag", @@ -499,9 +989,21 @@ export default defineMsdmdCollection({ "timeout": "20" }, "file": "tests/test_repo_loto.py", - "id": "check_close_deletes_tag" + "id": "check_close_deletes_tag", + "origin": "msdmd-block", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "pointer": "block:CHECKS/id:check_close_deletes_tag" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_latest_test_wins", "block": "CHECKS", "fields": { "call": "self::test_latest_test_wins", @@ -512,9 +1014,21 @@ export default defineMsdmdCollection({ "timeout": "20" }, "file": "tests/test_repo_loto.py", - "id": "check_latest_test_wins" + "id": "check_latest_test_wins", + "origin": "msdmd-block", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "pointer": "block:CHECKS/id:check_latest_test_wins" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_one_commit_per_session", "block": "CHECKS", "fields": { "call": "self::test_one_commit_per_session", @@ -525,9 +1039,21 @@ export default defineMsdmdCollection({ "timeout": "20" }, "file": "tests/test_repo_loto.py", - "id": "check_one_commit_per_session" + "id": "check_one_commit_per_session", + "origin": "msdmd-block", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "pointer": "block:CHECKS/id:check_one_commit_per_session" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_open_never_dirties", "block": "CHECKS", "fields": { "call": "self::test_open_never_dirties", @@ -538,9 +1064,21 @@ export default defineMsdmdCollection({ "timeout": "20" }, "file": "tests/test_repo_loto.py", - "id": "check_open_never_dirties" + "id": "check_open_never_dirties", + "origin": "msdmd-block", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "pointer": "block:CHECKS/id:check_open_never_dirties" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scar_blocks_work", "block": "CHECKS", "fields": { "call": "self::test_scar_blocks_work", @@ -551,9 +1089,21 @@ export default defineMsdmdCollection({ "timeout": "20" }, "file": "tests/test_repo_loto.py", - "id": "check_scar_blocks_work" + "id": "check_scar_blocks_work", + "origin": "msdmd-block", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "pointer": "block:CHECKS/id:check_scar_blocks_work" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scope_enforced", "block": "CHECKS", "fields": { "call": "self::test_scope_enforced", @@ -564,9 +1114,21 @@ export default defineMsdmdCollection({ "timeout": "20" }, "file": "tests/test_repo_loto.py", - "id": "check_scope_enforced" + "id": "check_scope_enforced", + "origin": "msdmd-block", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "pointer": "block:CHECKS/id:check_scope_enforced" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/MODULE_BUILD/repo_loto_evidence", "block": "MODULE_BUILD", "fields": { "internal_surface": "_mk_repo, _run, _loto, _parse_block, _resolve_call, _requires_met", @@ -579,9 +1141,21 @@ export default defineMsdmdCollection({ "unresolved": "mutation-level verification that checks actually exercise their contracts" }, "file": "tests/test_repo_loto.py", - "id": "repo_loto_evidence" + "id": "repo_loto_evidence", + "origin": "msdmd-block", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "pointer": "block:MODULE_BUILD/id:repo_loto_evidence" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_python_numeric_field_contract", "block": "CHECKS", "fields": { "call": "self::test_parser_field_contract", @@ -592,9 +1166,21 @@ export default defineMsdmdCollection({ "timeout": "10" }, "file": "tests/test_universal_parser.py", - "id": "check_msdmd_python_numeric_field_contract" + "id": "check_msdmd_python_numeric_field_contract", + "origin": "msdmd-block", + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "pointer": "block:CHECKS/id:check_msdmd_python_numeric_field_contract" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_typescript_numeric_field_contract", "block": "CHECKS", "fields": { "call": "self::test_typescript_parser_field_contract", @@ -605,17 +1191,21 @@ export default defineMsdmdCollection({ "timeout": "10" }, "file": "tests/test_universal_parser.py", - "id": "check_msdmd_typescript_numeric_field_contract" - }, - { - "block": "DOCS", - "fields": { - "summary": "second" + "id": "check_msdmd_typescript_numeric_field_contract", + "origin": "msdmd-block", + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "pointer": "block:CHECKS/id:check_msdmd_typescript_numeric_field_contract" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" }, - "file": "tests/test_universal_parser.py", - "id": "second_docs" + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#block/CONTRACTS/org_rec_append_only", "block": "CONTRACTS", "fields": { "class": "filesystem", @@ -623,9 +1213,21 @@ export default defineMsdmdCollection({ "then": "existing bytes remain before the new report and the file is not truncated" }, "file": "tools/aggregate_org_rec.py", - "id": "org_rec_append_only" + "id": "org_rec_append_only", + "origin": "msdmd-block", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "pointer": "block:CONTRACTS/id:org_rec_append_only" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#block/CONTRACTS/org_rec_missing_repo_visible", "block": "CONTRACTS", "fields": { "class": "evidence", @@ -633,9 +1235,21 @@ export default defineMsdmdCollection({ "then": "the aggregate includes the repository in a visible hmmm/missing list" }, "file": "tools/aggregate_org_rec.py", - "id": "org_rec_missing_repo_visible" + "id": "org_rec_missing_repo_visible", + "origin": "msdmd-block", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "pointer": "block:CONTRACTS/id:org_rec_missing_repo_visible" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#block/CONTRACTS/org_rec_remaining_fallback", "block": "CONTRACTS", "fields": { "class": "evidence", @@ -643,9 +1257,21 @@ export default defineMsdmdCollection({ "then": "the aggregate reports the Remaining bullets as follow-up recommendations" }, "file": "tools/aggregate_org_rec.py", - "id": "org_rec_remaining_fallback" + "id": "org_rec_remaining_fallback", + "origin": "msdmd-block", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "pointer": "block:CONTRACTS/id:org_rec_remaining_fallback" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#block/MODULE_BUILD/org_rec_aggregation_runner", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -664,9 +1290,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "none" }, "file": "tools/aggregate_org_rec.py", - "id": "org_rec_aggregation_runner" + "id": "org_rec_aggregation_runner", + "origin": "msdmd-block", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "pointer": "block:MODULE_BUILD/id:org_rec_aggregation_runner" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#block/MODULE_BUILD/skill_lib_ai_launcher", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -688,9 +1326,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "provider key values are only copied from the VM login environment into the VM tmux server environment" }, "file": "tools/ai.sh", - "id": "skill_lib_ai_launcher" + "id": "skill_lib_ai_launcher", + "origin": "msdmd-block", + "source": { + "content_sha256": "b11bce0772f12eb320c52fc2abf81b4eaae2ba6a12b70a099cf13c0d6414da3e", + "file": "tools/ai.sh", + "location": { + "pointer": "block:MODULE_BUILD/id:skill_lib_ai_launcher" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#block/MODULE_BUILD/gonol_authority_gate", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -712,9 +1362,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "none" }, "file": "tools/check_gonol_authority.sh", - "id": "gonol_authority_gate" + "id": "gonol_authority_gate", + "origin": "msdmd-block", + "source": { + "content_sha256": "1875f8c9e922642b3707632e93282efe6390b5ae29ab9d1f1d283246ba7868ca", + "file": "tools/check_gonol_authority.sh", + "location": { + "pointer": "block:MODULE_BUILD/id:gonol_authority_gate" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#block/MODULE_BUILD/skill_lib_ai_installer", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -736,9 +1398,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "no credentials read or written" }, "file": "tools/install_ai.sh", - "id": "skill_lib_ai_installer" + "id": "skill_lib_ai_installer", + "origin": "msdmd-block", + "source": { + "content_sha256": "534f315eb67c9657683868c37c8e348eb60f40d8bdf4fcc95c6ac27833fadce1", + "file": "tools/install_ai.sh", + "location": { + "pointer": "block:MODULE_BUILD/id:skill_lib_ai_installer" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#block/CONTRACTS/org_ratio_oddities_visible", "block": "CONTRACTS", "fields": { "class": "evidence", @@ -746,9 +1420,21 @@ export default defineMsdmdCollection({ "then": "build_report lists a human-readable oddity for that repo" }, "file": "tools/org_ratio_compare.py", - "id": "org_ratio_oddities_visible" + "id": "org_ratio_oddities_visible", + "origin": "msdmd-block", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "pointer": "block:CONTRACTS/id:org_ratio_oddities_visible" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#block/CONTRACTS/org_ratio_skips_vendored_skills", "block": "CONTRACTS", "fields": { "class": "evidence", @@ -756,9 +1442,21 @@ export default defineMsdmdCollection({ "then": "scalar/vector metrics exclude the vendored .agents tree" }, "file": "tools/org_ratio_compare.py", - "id": "org_ratio_skips_vendored_skills" + "id": "org_ratio_skips_vendored_skills", + "origin": "msdmd-block", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "pointer": "block:CONTRACTS/id:org_ratio_skips_vendored_skills" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#block/MODULE_BUILD/org_ratio_comparison_runner", "block": "MODULE_BUILD", "fields": { "admin_only": "false", @@ -777,9 +1475,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "none" }, "file": "tools/org_ratio_compare.py", - "id": "org_ratio_comparison_runner" + "id": "org_ratio_comparison_runner", + "origin": "msdmd-block", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "pointer": "block:MODULE_BUILD/id:org_ratio_comparison_runner" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/BOUNDARIES/vm_mcp_admin_broker_root_boundary", "block": "BOUNDARIES", "fields": { "admin_only": "true", @@ -792,9 +1502,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "read_write" }, "file": "vm-mcp/admin_broker.py", - "id": "vm_mcp_admin_broker_root_boundary" + "id": "vm_mcp_admin_broker_root_boundary", + "origin": "msdmd-block", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "pointer": "block:BOUNDARIES/id:vm_mcp_admin_broker_root_boundary" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/CONTRACTS/vm_mcp_admin_broker_peer_verified", "block": "CONTRACTS", "fields": { "class": "security", @@ -802,9 +1524,21 @@ export default defineMsdmdCollection({ "then": "SO_PEERCRED must identify the configured vmmcp service user or the request is rejected" }, "file": "vm-mcp/admin_broker.py", - "id": "vm_mcp_admin_broker_peer_verified" + "id": "vm_mcp_admin_broker_peer_verified", + "origin": "msdmd-block", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_admin_broker_peer_verified" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/CONTRACTS/vm_mcp_admin_exec_explicit_root", "block": "CONTRACTS", "fields": { "class": "authority", @@ -812,9 +1546,21 @@ export default defineMsdmdCollection({ "then": "the broker executes it as uid 0 and reports root mode explicitly in the result" }, "file": "vm-mcp/admin_broker.py", - "id": "vm_mcp_admin_exec_explicit_root" + "id": "vm_mcp_admin_exec_explicit_root", + "origin": "msdmd-block", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_admin_exec_explicit_root" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/CONTRACTS/vm_mcp_broker_execution_bounded", "block": "CONTRACTS", "fields": { "class": "safety", @@ -822,9 +1568,21 @@ export default defineMsdmdCollection({ "then": "the process group is killed, output is capped, and terminal evidence is returned" }, "file": "vm-mcp/admin_broker.py", - "id": "vm_mcp_broker_execution_bounded" + "id": "vm_mcp_broker_execution_bounded", + "origin": "msdmd-block", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_broker_execution_bounded" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/CONTRACTS/vm_mcp_user_exec_non_root", "block": "CONTRACTS", "fields": { "class": "security", @@ -832,9 +1590,21 @@ export default defineMsdmdCollection({ "then": "root is rejected and the child process drops uid/gid/groups to the requested non-root account before exec" }, "file": "vm-mcp/admin_broker.py", - "id": "vm_mcp_user_exec_non_root" + "id": "vm_mcp_user_exec_non_root", + "origin": "msdmd-block", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_user_exec_non_root" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/MODULE_BUILD/vm_mcp_personal_console_broker", "block": "MODULE_BUILD", "fields": { "admin_only": "true", @@ -853,9 +1623,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "read_write" }, "file": "vm-mcp/admin_broker.py", - "id": "vm_mcp_personal_console_broker" + "id": "vm_mcp_personal_console_broker", + "origin": "msdmd-block", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "pointer": "block:MODULE_BUILD/id:vm_mcp_personal_console_broker" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#block/BOUNDARIES/vm_mcp_admin_client_socket_boundary", "block": "BOUNDARIES", "fields": { "admin_only": "true", @@ -868,9 +1650,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "read_write" }, "file": "vm-mcp/admin_client.py", - "id": "vm_mcp_admin_client_socket_boundary" + "id": "vm_mcp_admin_client_socket_boundary", + "origin": "msdmd-block", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "pointer": "block:BOUNDARIES/id:vm_mcp_admin_client_socket_boundary" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#block/MODULE_BUILD/vm_mcp_admin_client", "block": "MODULE_BUILD", "fields": { "admin_only": "true", @@ -889,9 +1683,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "read_write" }, "file": "vm-mcp/admin_client.py", - "id": "vm_mcp_admin_client" + "id": "vm_mcp_admin_client", + "origin": "msdmd-block", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "pointer": "block:MODULE_BUILD/id:vm_mcp_admin_client" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_credentials_not_inherited", "block": "CONTRACTS", "fields": { "class": "security", @@ -899,9 +1705,21 @@ export default defineMsdmdCollection({ "then": "shell execution receives a sanitized environment rather than the service process environment" }, "file": "vm-mcp/policy.py", - "id": "vm_mcp_credentials_not_inherited" + "id": "vm_mcp_credentials_not_inherited", + "origin": "msdmd-block", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_credentials_not_inherited" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_listing_symlinks_not_followed", "block": "CONTRACTS", "fields": { "class": "security", @@ -909,9 +1727,21 @@ export default defineMsdmdCollection({ "then": "the listing reports the symlink itself and does not follow the target for file metadata" }, "file": "vm-mcp/policy.py", - "id": "vm_mcp_listing_symlinks_not_followed" + "id": "vm_mcp_listing_symlinks_not_followed", + "origin": "msdmd-block", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_listing_symlinks_not_followed" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_output_bounded", "block": "CONTRACTS", "fields": { "class": "safety", @@ -919,9 +1749,21 @@ export default defineMsdmdCollection({ "then": "the response is capped and reports truncation visibly" }, "file": "vm-mcp/policy.py", - "id": "vm_mcp_output_bounded" + "id": "vm_mcp_output_bounded", + "origin": "msdmd-block", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_output_bounded" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_personal_console_explicit", "block": "CONTRACTS", "fields": { "class": "security", @@ -929,9 +1771,21 @@ export default defineMsdmdCollection({ "then": "the deployment must explicitly select the personal-console profile" }, "file": "vm-mcp/policy.py", - "id": "vm_mcp_personal_console_explicit" + "id": "vm_mcp_personal_console_explicit", + "origin": "msdmd-block", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_personal_console_explicit" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_profile_default_read_only", "block": "CONTRACTS", "fields": { "class": "security", @@ -939,9 +1793,21 @@ export default defineMsdmdCollection({ "then": "writes, shell execution, user execution, and admin execution are refused" }, "file": "vm-mcp/policy.py", - "id": "vm_mcp_profile_default_read_only" + "id": "vm_mcp_profile_default_read_only", + "origin": "msdmd-block", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_profile_default_read_only" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_read_paths_confined", "block": "CONTRACTS", "fields": { "class": "security", @@ -949,9 +1815,21 @@ export default defineMsdmdCollection({ "then": "the resolved target must remain under VM_MCP_ROOT or the tool refuses access" }, "file": "vm-mcp/policy.py", - "id": "vm_mcp_read_paths_confined" + "id": "vm_mcp_read_paths_confined", + "origin": "msdmd-block", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_read_paths_confined" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_shell_cwd_confined", "block": "CONTRACTS", "fields": { "class": "security", @@ -959,9 +1837,21 @@ export default defineMsdmdCollection({ "then": "execution is refused before a process is spawned" }, "file": "vm-mcp/policy.py", - "id": "vm_mcp_shell_cwd_confined" + "id": "vm_mcp_shell_cwd_confined", + "origin": "msdmd-block", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_shell_cwd_confined" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_shell_execution_bounded", "block": "CONTRACTS", "fields": { "class": "safety", @@ -969,9 +1859,21 @@ export default defineMsdmdCollection({ "then": "output is capped, timed-out process groups are killed, and surviving descendants are killed before return" }, "file": "vm-mcp/policy.py", - "id": "vm_mcp_shell_execution_bounded" + "id": "vm_mcp_shell_execution_bounded", + "origin": "msdmd-block", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_shell_execution_bounded" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_workspace_writes_confined", "block": "CONTRACTS", "fields": { "class": "security", @@ -979,9 +1881,21 @@ export default defineMsdmdCollection({ "then": "the resolved path remains under VM_MCP_ROOT and the profile must permit workspace mutation" }, "file": "vm-mcp/policy.py", - "id": "vm_mcp_workspace_writes_confined" + "id": "vm_mcp_workspace_writes_confined", + "origin": "msdmd-block", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_workspace_writes_confined" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#block/CONTRACTS/vm_mcp_host_write_confined", "block": "CONTRACTS", "fields": { "class": "security", @@ -989,9 +1903,21 @@ export default defineMsdmdCollection({ "then": "NoNewPrivileges remains enabled, Linux capabilities are empty, and direct service writes stay under VM_MCP_ROOT" }, "file": "vm-mcp/server.py", - "id": "vm_mcp_host_write_confined" + "id": "vm_mcp_host_write_confined", + "origin": "msdmd-block", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_host_write_confined" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#block/CONTRACTS/vm_mcp_loopback_only", "block": "CONTRACTS", "fields": { "class": "security", @@ -999,9 +1925,21 @@ export default defineMsdmdCollection({ "then": "Streamable HTTP binds to 127.0.0.1 on /mcp rather than a public interface" }, "file": "vm-mcp/server.py", - "id": "vm_mcp_loopback_only" + "id": "vm_mcp_loopback_only", + "origin": "msdmd-block", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_loopback_only" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#block/CONTRACTS/vm_mcp_metadata_credentials_blocked", "block": "CONTRACTS", "fields": { "class": "security", @@ -1009,9 +1947,21 @@ export default defineMsdmdCollection({ "then": "the systemd network policy denies 169.254.169.254" }, "file": "vm-mcp/server.py", - "id": "vm_mcp_metadata_credentials_blocked" + "id": "vm_mcp_metadata_credentials_blocked", + "origin": "msdmd-block", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_metadata_credentials_blocked" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#block/CONTRACTS/vm_mcp_personal_console_root_separate", "block": "CONTRACTS", "fields": { "class": "authority", @@ -1019,9 +1969,21 @@ export default defineMsdmdCollection({ "then": "root execution occurs only in the separate Unix-socket broker and not by making the MCP service root" }, "file": "vm-mcp/server.py", - "id": "vm_mcp_personal_console_root_separate" + "id": "vm_mcp_personal_console_root_separate", + "origin": "msdmd-block", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "pointer": "block:CONTRACTS/id:vm_mcp_personal_console_root_separate" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#block/MODULE_BUILD/vm_mcp_control_plane", "block": "MODULE_BUILD", "fields": { "admin_only": "true", @@ -1042,9 +2004,21 @@ export default defineMsdmdCollection({ "user_data_boundary": "read_write" }, "file": "vm-mcp/server.py", - "id": "vm_mcp_control_plane" + "id": "vm_mcp_control_plane", + "origin": "msdmd-block", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "pointer": "block:MODULE_BUILD/id:vm_mcp_control_plane" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_admin_broker_peer_verified", "block": "CHECKS", "fields": { "call": "self::test_serve_source_uses_peer_credentials", @@ -1053,9 +2027,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_admin_broker_peer_verified" }, "file": "vm-mcp/tests/test_admin_broker.py", - "id": "check_vm_mcp_admin_broker_peer_verified" + "id": "check_vm_mcp_admin_broker_peer_verified", + "origin": "msdmd-block", + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_admin_broker_peer_verified" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_admin_exec_explicit_root", "block": "CHECKS", "fields": { "call": "self::test_admin_mode_selects_root", @@ -1064,9 +2050,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_admin_exec_explicit_root" }, "file": "vm-mcp/tests/test_admin_broker.py", - "id": "check_vm_mcp_admin_exec_explicit_root" + "id": "check_vm_mcp_admin_exec_explicit_root", + "origin": "msdmd-block", + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_admin_exec_explicit_root" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_broker_execution_bounded", "block": "CHECKS", "fields": { "call": "self::test_admin_execution_timeout_is_bounded_when_root", @@ -1075,9 +2073,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_broker_execution_bounded" }, "file": "vm-mcp/tests/test_admin_broker.py", - "id": "check_vm_mcp_broker_execution_bounded" + "id": "check_vm_mcp_broker_execution_bounded", + "origin": "msdmd-block", + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_broker_execution_bounded" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_user_exec_non_root", "block": "CHECKS", "fields": { "call": "self::test_user_mode_rejects_root", @@ -1086,9 +2096,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_user_exec_non_root" }, "file": "vm-mcp/tests/test_admin_broker.py", - "id": "check_vm_mcp_user_exec_non_root" + "id": "check_vm_mcp_user_exec_non_root", + "origin": "msdmd-block", + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_user_exec_non_root" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_loopback_config", "block": "CHECKS", "fields": { "call": "self::test_server_binds_loopback_only", @@ -1097,9 +2119,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_loopback_only" }, "file": "vm-mcp/tests/test_assets.py", - "id": "check_vm_mcp_loopback_config" + "id": "check_vm_mcp_loopback_config", + "origin": "msdmd-block", + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_loopback_config" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_metadata_denial", "block": "CHECKS", "fields": { "call": "self::test_systemd_blocks_cloud_metadata_address", @@ -1108,9 +2142,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_metadata_credentials_blocked" }, "file": "vm-mcp/tests/test_assets.py", - "id": "check_vm_mcp_metadata_denial" + "id": "check_vm_mcp_metadata_denial", + "origin": "msdmd-block", + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_metadata_denial" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_personal_console_root_separate", "block": "CHECKS", "fields": { "call": "self::test_personal_console_uses_separate_root_broker", @@ -1119,9 +2165,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_personal_console_root_separate" }, "file": "vm-mcp/tests/test_assets.py", - "id": "check_vm_mcp_personal_console_root_separate" + "id": "check_vm_mcp_personal_console_root_separate", + "origin": "msdmd-block", + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_personal_console_root_separate" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_systemd_write_boundary", "block": "CHECKS", "fields": { "call": "self::test_non_root_service_keeps_hardening", @@ -1130,9 +2188,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_host_write_confined" }, "file": "vm-mcp/tests/test_assets.py", - "id": "check_vm_mcp_systemd_write_boundary" + "id": "check_vm_mcp_systemd_write_boundary", + "origin": "msdmd-block", + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_systemd_write_boundary" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_environment_sanitized", "block": "CHECKS", "fields": { "call": "self::test_shell_does_not_inherit_unrelated_environment", @@ -1141,9 +2211,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_credentials_not_inherited" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_environment_sanitized" + "id": "check_vm_mcp_environment_sanitized", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_environment_sanitized" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_listing_symlink_not_followed", "block": "CHECKS", "fields": { "call": "self::test_listing_does_not_follow_symlink_metadata", @@ -1152,9 +2234,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_listing_symlinks_not_followed" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_listing_symlink_not_followed" + "id": "check_vm_mcp_listing_symlink_not_followed", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_listing_symlink_not_followed" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_output_bounded", "block": "CHECKS", "fields": { "call": "self::test_read_text_is_bounded", @@ -1163,9 +2257,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_output_bounded" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_output_bounded" + "id": "check_vm_mcp_output_bounded", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_output_bounded" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_parent_escape_rejected", "block": "CHECKS", "fields": { "call": "self::test_parent_escape_rejected", @@ -1174,9 +2280,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_read_paths_confined" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_parent_escape_rejected" + "id": "check_vm_mcp_parent_escape_rejected", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_parent_escape_rejected" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_personal_console_gate", "block": "CHECKS", "fields": { "call": "self::test_broker_exec_requires_personal_console", @@ -1185,9 +2303,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_personal_console_explicit" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_personal_console_gate" + "id": "check_vm_mcp_personal_console_gate", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_personal_console_gate" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_profile_default_read_only", "block": "CHECKS", "fields": { "call": "self::test_default_profile_is_read_only", @@ -1196,9 +2326,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_profile_default_read_only" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_profile_default_read_only" + "id": "check_vm_mcp_profile_default_read_only", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_profile_default_read_only" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_cwd_escape_rejected", "block": "CHECKS", "fields": { "call": "self::test_shell_cwd_escape_rejected", @@ -1207,9 +2349,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_shell_cwd_confined" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_shell_cwd_escape_rejected" + "id": "check_vm_mcp_shell_cwd_escape_rejected", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_shell_cwd_escape_rejected" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_output_bounded", "block": "CHECKS", "fields": { "call": "self::test_shell_output_is_bounded_while_draining", @@ -1218,9 +2372,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_shell_execution_bounded" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_shell_output_bounded" + "id": "check_vm_mcp_shell_output_bounded", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_shell_output_bounded" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_timeout", "block": "CHECKS", "fields": { "call": "self::test_shell_timeout_is_enforced", @@ -1229,9 +2395,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_shell_execution_bounded" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_shell_timeout" + "id": "check_vm_mcp_shell_timeout", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_shell_timeout" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_symlink_escape_rejected", "block": "CHECKS", "fields": { "call": "self::test_symlink_escape_rejected", @@ -1240,9 +2418,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_read_paths_confined" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_symlink_escape_rejected" + "id": "check_vm_mcp_symlink_escape_rejected", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_symlink_escape_rejected" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_workspace_write_confined", "block": "CHECKS", "fields": { "call": "self::test_write_and_move_remain_under_root", @@ -1251,9 +2441,21 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_workspace_writes_confined" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_workspace_write_confined" + "id": "check_vm_mcp_workspace_write_confined", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_workspace_write_confined" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" }, { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_workspace_write_gate", "block": "CHECKS", "fields": { "call": "self::test_write_requires_mutating_profile", @@ -1262,1005 +2464,160913 @@ export default defineMsdmdCollection({ "proves": "vm_mcp_workspace_writes_confined" }, "file": "vm-mcp/tests/test_policy.py", - "id": "check_vm_mcp_workspace_write_gate" + "id": "check_vm_mcp_workspace_write_gate", + "origin": "msdmd-block", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "pointer": "block:CHECKS/id:check_vm_mcp_workspace_write_gate" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared" } ], - "edges": [ + "diagnostics": [ { - "from": "vm_mcp_admin_broker_root_boundary", - "kind": "owns", - "source_block": "BOUNDARIES", - "source_id": "vm_mcp_admin_broker_root_boundary", - "to": "skill-lib vm-mcp maintainers" + "code": "unrecognized_license_text", + "message": "license identifier remains hmmm", + "reader_id": "license-text", + "severity": "warning", + "source": { + "content_sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30", + "file": "LICENSES/Apache-2.0.txt", + "location": { + "pointer": "document" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "status": "ambiguous" }, { - "from": "vm_mcp_admin_client_socket_boundary", - "kind": "owns", - "source_block": "BOUNDARIES", - "source_id": "vm_mcp_admin_client_socket_boundary", - "to": "skill-lib vm-mcp maintainers" + "code": "dynamic_module_loading", + "message": "dynamic module loading is not resolved", + "reader_id": "typescript-compiler", + "severity": "warning", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "status": "dynamic-unresolved" }, { - "from": "python_module_metadata_projection", - "kind": "exposes", - "source_block": "CAPABILITIES", - "source_id": "python_module_metadata_projection", - "to": "Python symbol identities" + "code": "dynamic_module_loading", + "message": "dynamic module loading is not resolved", + "reader_id": "typescript-compiler", + "severity": "warning", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "status": "dynamic-unresolved" + } + ], + "discovery": [ + { + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/.agents/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "python_module_metadata_projection", - "kind": "exposes", - "source_block": "CAPABILITIES", - "source_id": "python_module_metadata_projection", - "to": "deterministic JSONL projection" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/.git/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "python_module_metadata_projection", - "kind": "exposes", - "source_block": "CAPABILITIES", - "source_id": "python_module_metadata_projection", - "to": "freshness key" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/.mypy_cache/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "python_module_metadata_projection", - "kind": "exposes", - "source_block": "CAPABILITIES", - "source_id": "python_module_metadata_projection", - "to": "native docstrings" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/.pytest_cache/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "python_module_metadata_projection", - "kind": "exposes", - "source_block": "CAPABILITIES", - "source_id": "python_module_metadata_projection", - "to": "structurally attached comments" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/.skill-lib/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "repo_collection_generator", - "kind": "exposes", - "source_block": "CAPABILITIES", - "source_id": "repo_collection_generator", - "to": "collect" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/.tox/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "repo_collection_generator", - "kind": "exposes", - "source_block": "CAPABILITIES", - "source_id": "repo_collection_generator", - "to": "render_typescript" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/.venv/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "check_clear_is_empty_commit", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_clear_is_empty_commit", - "to": "self::test_clear_is_empty_commit" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/__pycache__/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "check_clear_is_empty_commit", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_clear_is_empty_commit", - "to": "loto_clear_is_empty_commit" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/build/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "check_clear_is_empty_commit", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_clear_is_empty_commit", - "to": "git" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/dist/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "check_clear_is_empty_commit", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_clear_is_empty_commit", - "to": "posix_shell" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/node_modules/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "check_clear_is_empty_commit", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_clear_is_empty_commit", - "to": "python3" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/target/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "check_close_deletes_tag", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_close_deletes_tag", - "to": "self::test_close_deletes_tag" + "content_sha256": "hmmm", + "entry_kind": "subtree", + "file": "**/venv/**", + "reader_ids": [], + "reason": "configured-subtree", + "status": "excluded" }, { - "from": "check_close_deletes_tag", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_close_deletes_tag", - "to": "loto_close_deletes_tag" + "content_sha256": "2291d1897b60f1b9c56050d855eb287c5984fd18f94124d9c3bc016951c3be80", + "entry_kind": "file", + "file": ".claude-plugin/marketplace.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 752, + "status": "supported" }, { - "from": "check_close_deletes_tag", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_close_deletes_tag", - "to": "git" + "content_sha256": "642e69831ffab7f27ae41fbb4fd2b4a6c2a1df422133005886e0444d224d2eb4", + "entry_kind": "file", + "file": ".codex-plugin/plugin.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 1045, + "status": "supported" }, { - "from": "check_close_deletes_tag", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_close_deletes_tag", - "to": "posix_shell" + "content_sha256": "000c5a6e3351e7193988188de6137fccf51da02191eb0cfa60cf215e1264713c", + "entry_kind": "file", + "file": ".github/FUNDING.yml", + "reader_ids": [ + "yaml-core", + "metadata-standards" + ], + "size": 80, + "status": "supported" }, { - "from": "check_close_deletes_tag", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_close_deletes_tag", - "to": "python3" + "content_sha256": "5cee80a2a26176fe937224ff0365a826d180bd2784dcfb9a7fa4bfcbf8259bed", + "entry_kind": "file", + "file": ".github/workflows/ci.yml", + "reader_ids": [ + "yaml-core", + "metadata-standards" + ], + "size": 1749, + "status": "supported" }, { - "from": "check_latest_test_wins", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_latest_test_wins", - "to": "self::test_latest_test_wins" + "content_sha256": "1949c58d8ee22ea28c112df95ec78d42903066f318c8fb8a1a436bf7b63c6d07", + "entry_kind": "file", + "file": ".github/workflows/consumer-drift.yml", + "reader_ids": [ + "yaml-core", + "metadata-standards" + ], + "size": 2642, + "status": "supported" }, { - "from": "check_latest_test_wins", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_latest_test_wins", - "to": "loto_latest_test_wins" + "content_sha256": "bb6ec9588c41c82e2674be0ecd2933a41df7aedc5e160c2e222f19860b5d8491", + "entry_kind": "file", + "file": ".github/workflows/hygiene.yml", + "reader_ids": [ + "yaml-core", + "metadata-standards" + ], + "size": 578, + "status": "supported" }, { - "from": "check_latest_test_wins", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_latest_test_wins", - "to": "git" + "content_sha256": "1c59c80391b92c7d74c90f5724911fa4e79c8490dca69560e8b064c55fe34456", + "entry_kind": "file", + "file": ".gitignore", + "reader_ids": [ + "gitignore-lines" + ], + "size": 279, + "status": "supported" }, { - "from": "check_latest_test_wins", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_latest_test_wins", - "to": "posix_shell" + "content_sha256": "9d30b25e7d6e73fb1613ade0d06963e254847b18ff69b674ec052582452639e1", + "entry_kind": "file", + "file": "AGENTS.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 15044, + "status": "supported" }, { - "from": "check_latest_test_wins", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_latest_test_wins", - "to": "python3" + "content_sha256": "e741fa591ddc63f77bbf90f1b4c2d58410e8d3e6d6950ae0b90a169f7dd24ed1", + "entry_kind": "file", + "file": "ATTRIBUTION.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 1616, + "status": "supported" }, { - "from": "check_module_projection_freshness_binds_source_and_reader", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_module_projection_freshness_binds_source_and_reader", - "to": "self::test_freshness_key_changes_with_source_or_reader" + "content_sha256": "fdfd035b131c7d709a61043f6097ee45ca61ac347624f020793db3fa355537f7", + "entry_kind": "file", + "file": "CLAUDE.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 28174, + "status": "supported" }, { - "from": "check_module_projection_freshness_binds_source_and_reader", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_module_projection_freshness_binds_source_and_reader", - "to": "module_projection_freshness_binds_source_and_reader" + "content_sha256": "3f3d9e0024b1921b067d6f7f88deb4a60cbe7a78e76c64e3f1d7fc3b779b9d04", + "entry_kind": "file", + "file": "LICENSE", + "reader_ids": [ + "license-text" + ], + "size": 16726, + "status": "supported" }, { - "from": "check_module_projection_freshness_binds_source_and_reader", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_module_projection_freshness_binds_source_and_reader", - "to": "python3" + "content_sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30", + "entry_kind": "file", + "file": "LICENSES/Apache-2.0.txt", + "reader_ids": [ + "license-text" + ], + "size": 11358, + "status": "partial" }, { - "from": "check_module_projection_line_shift_stability", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_module_projection_line_shift_stability", - "to": "self::test_line_insertions_preserve_symbol_identity_and_attachment" + "content_sha256": "233835b2cea28bbe0061e79703e2abcf11de9952a226ff189a03ce04522396c0", + "entry_kind": "file", + "file": "MSDMD_COMPLIANCE_AUDIT.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 17997, + "status": "supported" }, { - "from": "check_module_projection_line_shift_stability", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_module_projection_line_shift_stability", - "to": "module_projection_line_shift_stability" + "content_sha256": "f0829b6195ad2e23ebfb4cc9b9353a6257092d91675a3df3dae18f15e664703c", + "entry_kind": "file", + "file": "ORG_DISTRIBUTION.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 16396, + "status": "supported" }, { - "from": "check_module_projection_line_shift_stability", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_module_projection_line_shift_stability", - "to": "python3" + "content_sha256": "a0d56c2f51c2f955585f51cea9f370ed88be98feddb4a6f30f3424aa6a770891", + "entry_kind": "file", + "file": "README.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 26034, + "status": "supported" }, { - "from": "check_module_projection_never_executes_source", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_module_projection_never_executes_source", - "to": "self::test_projection_does_not_execute_inspected_source" + "content_sha256": "2c39d84dee5c7087a539c950231ee624408d4fdaa45f97a0627720615c254d4d", + "entry_kind": "file", + "file": "RESOURCE_RUN_INVARIANT.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 1983, + "status": "supported" }, { - "from": "check_module_projection_never_executes_source", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_module_projection_never_executes_source", - "to": "module_projection_never_executes_source" + "content_sha256": "afd54fed7065edf91a38c3b287dfc5bad763aec3d0b32b1d540a0ba67effd547", + "entry_kind": "file", + "file": "a0p-instancing/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 9670, + "status": "supported" }, { - "from": "check_module_projection_never_executes_source", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_module_projection_never_executes_source", - "to": "python3" + "content_sha256": "558a364d0e1f06474bdd5ce92196145f6e21567366b2fef8c3ad5df6c191016b", + "entry_kind": "file", + "file": "action-calibration/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 18091, + "status": "supported" }, { - "from": "check_msdmd_python_numeric_field_contract", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_msdmd_python_numeric_field_contract", - "to": "self::test_parser_field_contract" + "content_sha256": "e1e6268e5b1b3187fb4d7d870d7e0a0e2c2f0615d1a035edbcdfff5a86910aa4", + "entry_kind": "file", + "file": "action-calibration/examples/cases.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 2751, + "status": "supported" }, { - "from": "check_msdmd_python_numeric_field_contract", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_msdmd_python_numeric_field_contract", - "to": "msdmd_python_parser_preserves_field_names" + "content_sha256": "74f5494de0153e37e65f10abc06512e6fbfc327c77862720cc9707e3c2d1b6c4", + "entry_kind": "file", + "file": "action-calibration/references/savings-skill-audit.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 7779, + "status": "supported" }, { - "from": "check_msdmd_python_numeric_field_contract", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_msdmd_python_numeric_field_contract", - "to": "python3" + "content_sha256": "1be4c8be7d75114b06c3df800508f6c294db7bff3c865f60a3da0f568f01a54c", + "entry_kind": "file", + "file": "action-calibration/references/thread-derived-criteria.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 5749, + "status": "supported" }, { - "from": "check_msdmd_typescript_numeric_field_contract", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_msdmd_typescript_numeric_field_contract", - "to": "self::test_typescript_parser_field_contract" + "content_sha256": "faed73e0f4b63af03c4314477231bf07453e9739aa66cd454cfd6ac80537d206", + "entry_kind": "file", + "file": "agent-instantiation/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 13239, + "status": "supported" }, { - "from": "check_msdmd_typescript_numeric_field_contract", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_msdmd_typescript_numeric_field_contract", - "to": "msdmd_typescript_parser_preserves_field_names" + "content_sha256": "28db85eccfcb4c682c0bc55def4932df0832806564dc1f28887a0987a279d3fc", + "entry_kind": "file", + "file": "canon/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 3851, + "status": "supported" }, { - "from": "check_msdmd_typescript_numeric_field_contract", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_msdmd_typescript_numeric_field_contract", - "to": "node24" + "content_sha256": "25415e0c97ca20892f1af1cd7089f23d98b1310c430b4258e4a207a608b66c51", + "entry_kind": "file", + "file": "cap-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 5649, + "status": "supported" }, { - "from": "check_msdmd_typescript_numeric_field_contract", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_msdmd_typescript_numeric_field_contract", - "to": "python3" + "content_sha256": "4043e8c527eb887aa614be8d5e34c2589beef16e53770f5fc26f430e8c69524b", + "entry_kind": "file", + "file": "char-compress/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 18728, + "status": "supported" }, { - "from": "check_one_commit_per_session", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_one_commit_per_session", - "to": "self::test_one_commit_per_session" + "content_sha256": "20ac24f517ad4224a2e82dda48bba42a4d5ee9a0ab24f234fde1571a11a894bd", + "entry_kind": "file", + "file": "char-compress/fixtures.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 2738, + "status": "supported" }, { - "from": "check_one_commit_per_session", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_one_commit_per_session", - "to": "loto_one_commit_per_session" + "content_sha256": "4ca0d131514954517f0d2ecc39964698fd3ecd06bfeec4e5f1cb163795453e8e", + "entry_kind": "file", + "file": "data-visualization/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 17969, + "status": "supported" }, { - "from": "check_one_commit_per_session", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_one_commit_per_session", - "to": "git" + "content_sha256": "c92106fe2317f42e3757201b6a93e4ab58675c5ee3c7c5f7b58aa36f759924a6", + "entry_kind": "file", + "file": "data-visualization/examples/information-design-manifest.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 1263, + "status": "supported" }, { - "from": "check_one_commit_per_session", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_one_commit_per_session", - "to": "posix_shell" + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "entry_kind": "file", + "file": "data-visualization/information_design_audit.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 6662, + "status": "supported" }, { - "from": "check_one_commit_per_session", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_one_commit_per_session", - "to": "python3" + "content_sha256": "ba90247e86dea8f9a1aae76a348d714d05e7061a79082925a527edb125606bad", + "entry_kind": "file", + "file": "data-visualization/references/information-design-evidence.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 6977, + "status": "supported" }, { - "from": "check_open_never_dirties", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_open_never_dirties", - "to": "self::test_open_never_dirties" + "content_sha256": "62eecb020ce1099ea4e5b2a982f12b34f1f849e152b12e0b642c0429a31a139b", + "entry_kind": "file", + "file": "data-visualization/visual-grammar.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 3043, + "status": "supported" }, { - "from": "check_open_never_dirties", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_open_never_dirties", - "to": "loto_open_never_dirties" + "content_sha256": "4cc9480007527a023f45b02aedc4bbc3b55eed6e02ca8da6b5d9b33017f23306", + "entry_kind": "file", + "file": "deps-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 5697, + "status": "supported" }, { - "from": "check_open_never_dirties", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_open_never_dirties", - "to": "git" + "content_sha256": "8f23e0596b40d9a042699c0183dfe4e28d6456dbd8d7433de25f6de0469d6fc3", + "entry_kind": "file", + "file": "distributed-publication/README.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 674, + "status": "supported" }, { - "from": "check_open_never_dirties", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_open_never_dirties", - "to": "posix_shell" + "content_sha256": "0c97c012eee6486f4ce5d2d21fc62023d048d294c721cc5081462b63e893b3d7", + "entry_kind": "file", + "file": "distributed-publication/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 16097, + "status": "supported" }, { - "from": "check_open_never_dirties", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_open_never_dirties", - "to": "python3" + "content_sha256": "b680e7de8a1d32b0a2d23cbb7d183c77b8bc5b7366a23f7a99739027516dc582", + "entry_kind": "file", + "file": "distributed-publication/examples/manifest.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 1638, + "status": "supported" }, { - "from": "check_org_ratio_oddities_visible", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_org_ratio_oddities_visible", - "to": "self::test_ratio_report_lists_low_coverage_oddity" + "content_sha256": "a797829f727aa63ec009212eb3e9259e18322443458733c88da5fe2d8b1f4c7d", + "entry_kind": "file", + "file": "doc-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 5428, + "status": "supported" }, { - "from": "check_org_ratio_oddities_visible", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_org_ratio_oddities_visible", - "to": "org_ratio_oddities_visible" + "content_sha256": "335cc1240c56c516e16c0c1e99f410c95bc186d966bedff8e276120fd80e6978", + "entry_kind": "file", + "file": "docs/chapter-3.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 7766, + "status": "supported" }, { - "from": "check_org_ratio_oddities_visible", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_org_ratio_oddities_visible", - "to": "posix_shell" + "content_sha256": "d917cfd0d541b858f43aa1b5bb429fe9c53f5ec35adef642a26c9eecbbf55acf", + "entry_kind": "file", + "file": "docs/icon.svg", + "reader_ids": [ + "svg-metadata" + ], + "size": 1229, + "status": "supported" }, { - "from": "check_org_ratio_oddities_visible", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_org_ratio_oddities_visible", - "to": "python3" + "content_sha256": "b270d727507c8379331d614f20e5d4b3367a960de49760152676ca7169c8e6c9", + "entry_kind": "file", + "file": "docs/production-readiness.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 2478, + "status": "supported" }, { - "from": "check_org_ratio_skips_vendored_skills", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_org_ratio_skips_vendored_skills", - "to": "self::test_ratio_metrics_skip_vendored_agents" + "content_sha256": "255d451f4eca9d2257042a725b8490e9f668ec45be833885ef0905bce04df178", + "entry_kind": "file", + "file": "docs/propagation-checklist.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 2958, + "status": "supported" }, { - "from": "check_org_ratio_skips_vendored_skills", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_org_ratio_skips_vendored_skills", - "to": "org_ratio_skips_vendored_skills" + "content_sha256": "d0aa1a8178bf8324cef6101dafec91a80626f83bb8f3d1ce0421d2b08e28e114", + "entry_kind": "file", + "file": "docs/runner-config-guidance.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 8731, + "status": "supported" }, { - "from": "check_org_ratio_skips_vendored_skills", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_org_ratio_skips_vendored_skills", - "to": "posix_shell" + "content_sha256": "807ce96412196e00f9b9b6de3628297740e7f6510498f8afe3940f1b29082171", + "entry_kind": "file", + "file": "docs/work-graphs/repository-plan-report.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 8850, + "status": "supported" }, { - "from": "check_org_ratio_skips_vendored_skills", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_org_ratio_skips_vendored_skills", - "to": "python3" + "content_sha256": "876c4bf7f1505a9c9adfb482d139aacd1ef60c641e206e85bdc09535f5f88403", + "entry_kind": "file", + "file": "doctrine/msdmd-checks.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 5949, + "status": "supported" }, { - "from": "check_org_rec_append_only", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_org_rec_append_only", - "to": "self::test_aggregate_append_preserves_existing_content" + "content_sha256": "51f690e0cdf2f272c9428dbc9f80ec97052cc24998b124451ed227c135bc0754", + "entry_kind": "file", + "file": "domain-claims/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 14092, + "status": "supported" }, { - "from": "check_org_rec_append_only", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_org_rec_append_only", - "to": "org_rec_append_only" + "content_sha256": "a8624e7fd168ce88fae1f7f512fcbac706e75de987cad4ffb40e2c49f9b41439", + "entry_kind": "file", + "file": "epac-selection-display/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 11389, + "status": "supported" }, { - "from": "check_org_rec_append_only", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_org_rec_append_only", - "to": "posix_shell" + "content_sha256": "8ef696d80e1c13f44039cae09965aa87927b3ed65e0c726eb0aa9f637f1af788", + "entry_kind": "file", + "file": "epac-selection-display/STACK_SOURCE_FIXTURE.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 953, + "status": "supported" }, { - "from": "check_org_rec_append_only", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_org_rec_append_only", - "to": "python3" + "content_sha256": "b641cbc5cecc613d5065ddd5531cc88659b1f37ff9e9f3632cafbeb6501334c8", + "entry_kind": "file", + "file": "explore-data/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 12845, + "status": "supported" }, { - "from": "check_org_rec_missing_repo_visible", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_org_rec_missing_repo_visible", - "to": "self::test_aggregate_lists_missing_rec_files" + "content_sha256": "e0866a17bf653185abc32e2f39bec4a8311a429b62ff2d4d536d112cc4d5a806", + "entry_kind": "file", + "file": "fresh-making/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 18683, + "status": "supported" }, { - "from": "check_org_rec_missing_repo_visible", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_org_rec_missing_repo_visible", - "to": "org_rec_missing_repo_visible" + "content_sha256": "273b9adb9f50e2bc1d0dd6c7620bef2ee3539aa76b1fc8870482a21ef2abc81c", + "entry_kind": "file", + "file": "gonol-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 8441, + "status": "supported" }, { - "from": "check_org_rec_missing_repo_visible", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_org_rec_missing_repo_visible", - "to": "posix_shell" + "content_sha256": "8a9c7fadaa39fe38c31baf49f542681184619b60beac4f553cb3f5e1be9b9c10", + "entry_kind": "file", + "file": "interdependent-work-graph/PORTFOLIO_PLAN.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 7781, + "status": "supported" }, { - "from": "check_org_rec_missing_repo_visible", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_org_rec_missing_repo_visible", - "to": "python3" + "content_sha256": "77b4d6af8a3150b45c9d0bb254252f2e82dcf72864e6e2a363e7478ef7c5a01e", + "entry_kind": "file", + "file": "interdependent-work-graph/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 12593, + "status": "supported" }, { - "from": "check_org_rec_remaining_fallback", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_org_rec_remaining_fallback", - "to": "self::test_aggregate_uses_remaining_when_latest_block_has_no_recommendations" + "content_sha256": "5a40c0c7362e1a1fa77d8e8132084e3deac927d870ac57dc760c2c85d08c925a", + "entry_kind": "file", + "file": "interdependent-work-graph/portfolio-plan.schema.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 3747, + "status": "supported" }, { - "from": "check_org_rec_remaining_fallback", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_org_rec_remaining_fallback", - "to": "org_rec_remaining_fallback" + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "entry_kind": "file", + "file": "interdependent-work-graph/portfolio_plan.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 12142, + "status": "supported" }, { - "from": "check_org_rec_remaining_fallback", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_org_rec_remaining_fallback", - "to": "posix_shell" + "content_sha256": "f04f1583be8725511113e2bb3280bf28459ad39824687bf8bcd0761c1bd14e80", + "entry_kind": "file", + "file": "interdependent-work-graph/repository-plan-report.schema.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 4705, + "status": "supported" }, { - "from": "check_org_rec_remaining_fallback", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_org_rec_remaining_fallback", - "to": "python3" + "content_sha256": "df9a67ed1efbec408247883142e4bbddf11d93afa39ef1d8cdb2a65fb28a2403", + "entry_kind": "file", + "file": "llms-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 7169, + "status": "supported" }, { - "from": "check_scar_blocks_work", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_scar_blocks_work", - "to": "self::test_scar_blocks_work" + "content_sha256": "d4ca5833418e3af7617957fe3a0d6f28b21a260dfb85c73e9e72736b0c4231fe", + "entry_kind": "file", + "file": "llms.txt", + "reader_ids": [ + "llms-text" + ], + "size": 2462, + "status": "supported" }, { - "from": "check_scar_blocks_work", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_scar_blocks_work", - "to": "loto_scar_blocks_work" + "content_sha256": "d280c6b1fd17e76cc97a1f77e25993f37ea9e1387199a1f713e30fbc32deef5b", + "entry_kind": "file", + "file": "llms/__init__.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 209, + "status": "supported" }, { - "from": "check_scar_blocks_work", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_scar_blocks_work", - "to": "git" + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "entry_kind": "file", + "file": "llms/build.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 8265, + "status": "supported" }, { - "from": "check_scar_blocks_work", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_scar_blocks_work", - "to": "posix_shell" + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "entry_kind": "file", + "file": "llms/metadata.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 2425, + "status": "supported" }, { - "from": "check_scar_blocks_work", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_scar_blocks_work", - "to": "python3" + "content_sha256": "11d0eaa099e3d12d59240eee6675ec9d1d6ac81b8d28d29689870afef26d5ce6", + "entry_kind": "file", + "file": "loop-eng/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 7523, + "status": "supported" }, { - "from": "check_scope_enforced", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_scope_enforced", - "to": "self::test_scope_enforced" + "content_sha256": "453a183e33fe4c3d8e7dc000cb649da9ac5baec3f29205db9e373c20abd9a9b6", + "entry_kind": "file", + "file": "manifest/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 6340, + "status": "supported" }, { - "from": "check_scope_enforced", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_scope_enforced", - "to": "loto_scope_enforced" + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "entry_kind": "file", + "file": "manifest/generate.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 11360, + "status": "supported" }, { - "from": "check_scope_enforced", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_scope_enforced", - "to": "git" + "content_sha256": "f09cdc7b15a2a0a8f3f315743317aa1b89eeb458f436ae59c03228b4b52115dc", + "entry_kind": "file", + "file": "meta-module-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 7626, + "status": "supported" }, { - "from": "check_scope_enforced", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_scope_enforced", - "to": "posix_shell" + "content_sha256": "a11283b9f10a45a37518851f95015d0310771a4d6f7237b43be23db2a5e12412", + "entry_kind": "file", + "file": "meta/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 8713, + "status": "supported" }, { - "from": "check_scope_enforced", - "kind": "requires", - "source_block": "CHECKS", - "source_id": "check_scope_enforced", - "to": "python3" + "content_sha256": "7b958e227edf4521d13bd529bf9b5028d8c5d75b7873c2a7f7b8ffd084252af4", + "entry_kind": "file", + "file": "msdmd/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 23263, + "status": "supported" }, { - "from": "check_vm_mcp_admin_broker_peer_verified", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_admin_broker_peer_verified", - "to": "self::test_serve_source_uses_peer_credentials" + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "entry_kind": "file", + "file": "msdmd/collect.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 37552, + "status": "supported" }, { - "from": "check_vm_mcp_admin_broker_peer_verified", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_admin_broker_peer_verified", - "to": "vm_mcp_admin_broker_peer_verified" + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "entry_kind": "file", + "file": "msdmd/collection.ts", + "reader_ids": [ + "typescript-compiler", + "msdmd-ratios" + ], + "size": 6995, + "status": "supported" }, { - "from": "check_vm_mcp_admin_exec_explicit_root", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_admin_exec_explicit_root", - "to": "self::test_admin_mode_selects_root" + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "entry_kind": "file", + "file": "msdmd/formats.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 8615, + "status": "supported" }, { - "from": "check_vm_mcp_admin_exec_explicit_root", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_admin_exec_explicit_root", - "to": "vm_mcp_admin_exec_explicit_root" + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "entry_kind": "file", + "file": "msdmd/grammar_code.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 8032, + "status": "supported" }, { - "from": "check_vm_mcp_broker_execution_bounded", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_broker_execution_bounded", - "to": "self::test_admin_execution_timeout_is_bounded_when_root" + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "entry_kind": "file", + "file": "msdmd/module-projection.schema.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 7526, + "status": "supported" }, { - "from": "check_vm_mcp_broker_execution_bounded", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_broker_execution_bounded", - "to": "vm_mcp_broker_execution_bounded" + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "entry_kind": "file", + "file": "msdmd/module_projection.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 42542, + "status": "supported" }, { - "from": "check_vm_mcp_environment_sanitized", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_environment_sanitized", - "to": "self::test_shell_does_not_inherit_unrelated_environment" + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "entry_kind": "file", + "file": "msdmd/native_code.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 14741, + "status": "supported" }, { - "from": "check_vm_mcp_environment_sanitized", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_environment_sanitized", - "to": "vm_mcp_credentials_not_inherited" + "content_sha256": "aaa0e822e8c9ec33c97b31a1a72622d427814b29ce21d9884514cc009ed60e67", + "entry_kind": "file", + "file": "msdmd/package-lock.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 667, + "status": "supported" }, { - "from": "check_vm_mcp_listing_symlink_not_followed", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_listing_symlink_not_followed", - "to": "self::test_listing_does_not_follow_symlink_metadata" + "content_sha256": "4860ed8625d09f6da8d0bf7f5977a786f195f660b0e93ac31e2560ad1bbe86ba", + "entry_kind": "file", + "file": "msdmd/package.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 205, + "status": "supported" }, { - "from": "check_vm_mcp_listing_symlink_not_followed", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_listing_symlink_not_followed", - "to": "vm_mcp_listing_symlinks_not_followed" + "content_sha256": "fd3de624f4a8d40985ee41128ae1331059795407b78b0fd675ebb3265d9e336a", + "entry_kind": "file", + "file": "msdmd/parsers/__init__.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 304, + "status": "supported" }, { - "from": "check_vm_mcp_loopback_config", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_loopback_config", - "to": "self::test_server_binds_loopback_only" + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "entry_kind": "file", + "file": "msdmd/parsers/universal.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 10988, + "status": "supported" }, { - "from": "check_vm_mcp_loopback_config", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_loopback_config", - "to": "vm_mcp_loopback_only" + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "entry_kind": "file", + "file": "msdmd/parsers/universal.ts", + "reader_ids": [ + "typescript-compiler", + "msdmd-ratios" + ], + "size": 9086, + "status": "supported" }, { - "from": "check_vm_mcp_metadata_denial", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_metadata_denial", - "to": "self::test_systemd_blocks_cloud_metadata_address" + "content_sha256": "c9cdc7dfe93cd7378820b37b25b672541c50faf8c42c41f36661fa55248dbadf", + "entry_kind": "file", + "file": "msdmd/python-module-reader.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 4545, + "status": "supported" }, { - "from": "check_vm_mcp_metadata_denial", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_metadata_denial", - "to": "vm_mcp_metadata_credentials_blocked" + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "entry_kind": "file", + "file": "msdmd/readers.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 56486, + "status": "supported" }, { - "from": "check_vm_mcp_output_bounded", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_output_bounded", - "to": "self::test_read_text_is_bounded" + "content_sha256": "b28b2b9afb746e4597b4af1b4f4375930f15385abe1383b78f05311c7d8caf77", + "entry_kind": "file", + "file": "msdmd/references/implemented-readers.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 8444, + "status": "supported" }, { - "from": "check_vm_mcp_output_bounded", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_output_bounded", - "to": "vm_mcp_output_bounded" + "content_sha256": "74709f8fa3ea0ea3216347d265743b2bfdf3cb5a72cfbe7fbb63bae57b7b818b", + "entry_kind": "file", + "file": "msdmd/references/metadata-conventions.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 23132, + "status": "supported" }, { - "from": "check_vm_mcp_parent_escape_rejected", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_parent_escape_rejected", - "to": "self::test_parent_escape_rejected" + "content_sha256": "b845de01c1943a4dd9494616548e3997d0a3f11df28265073bd5446fb86ae948", + "entry_kind": "file", + "file": "msdmd/requirements.txt", + "reader_ids": [ + "python-requirements" + ], + "size": 277, + "status": "supported" }, { - "from": "check_vm_mcp_parent_escape_rejected", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_parent_escape_rejected", - "to": "vm_mcp_read_paths_confined" + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "entry_kind": "file", + "file": "msdmd/standards.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 18669, + "status": "supported" }, { - "from": "check_vm_mcp_personal_console_gate", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_personal_console_gate", - "to": "self::test_broker_exec_requires_personal_console" + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "entry_kind": "file", + "file": "msdmd/typescript-reader.cjs", + "reader_ids": [ + "typescript-compiler", + "msdmd-ratios" + ], + "size": 7649, + "status": "partial" }, { - "from": "check_vm_mcp_personal_console_gate", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_personal_console_gate", - "to": "vm_mcp_personal_console_explicit" + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "entry_kind": "file", + "file": "msdmd/visualize.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 9832, + "status": "supported" }, { - "from": "check_vm_mcp_personal_console_root_separate", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_personal_console_root_separate", - "to": "self::test_personal_console_uses_separate_root_broker" + "content_sha256": "5f690073f9ae89e230e3299f7e018a9ac7ba91c155abd66e8379c39006a0c3ee", + "entry_kind": "file", + "file": "owner-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 5713, + "status": "supported" }, { - "from": "check_vm_mcp_personal_console_root_separate", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_personal_console_root_separate", - "to": "vm_mcp_personal_console_root_separate" + "content_sha256": "4c294a959e6858cb06d643c37f2f7ee8d965630ee2370a9d0fbbf1f19ca816cd", + "entry_kind": "file", + "file": "plain-lens/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 7926, + "status": "supported" }, { - "from": "check_vm_mcp_profile_default_read_only", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_profile_default_read_only", - "to": "self::test_default_profile_is_read_only" + "content_sha256": "e98961217b2381fc558a5f9024fc73671d4cde74433f29edc2ee88e8de65a586", + "entry_kind": "file", + "file": "project-incubation-graduation/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 20384, + "status": "supported" }, { - "from": "check_vm_mcp_profile_default_read_only", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_profile_default_read_only", - "to": "vm_mcp_profile_default_read_only" + "content_sha256": "44479e9a5546453d142ca6958c499f9ee1e858c850a1d6b9f2bfb12298109d02", + "entry_kind": "file", + "file": "ratios/HARMONICS.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 4380, + "status": "supported" }, { - "from": "check_vm_mcp_shell_cwd_escape_rejected", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_shell_cwd_escape_rejected", - "to": "self::test_shell_cwd_escape_rejected" + "content_sha256": "c34b06bd6c260f12fedddf67c9aeae80e076bc3d859f674ee451b888cc8fb3c2", + "entry_kind": "file", + "file": "ratios/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 14988, + "status": "supported" }, { - "from": "check_vm_mcp_shell_cwd_escape_rejected", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_shell_cwd_escape_rejected", - "to": "vm_mcp_shell_cwd_confined" + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "entry_kind": "file", + "file": "ratios/annotate_index.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 14920, + "status": "supported" }, { - "from": "check_vm_mcp_shell_output_bounded", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_shell_output_bounded", - "to": "self::test_shell_output_is_bounded_while_draining" + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "entry_kind": "file", + "file": "ratios/harmonic_math.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 10779, + "status": "supported" }, { - "from": "check_vm_mcp_shell_output_bounded", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_shell_output_bounded", - "to": "vm_mcp_shell_execution_bounded" + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "entry_kind": "file", + "file": "ratios/harmonics.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 15313, + "status": "supported" }, { - "from": "check_vm_mcp_shell_timeout", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_shell_timeout", - "to": "self::test_shell_timeout_is_enforced" + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "entry_kind": "file", + "file": "ratios/ratios_check.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 10664, + "status": "supported" }, { - "from": "check_vm_mcp_shell_timeout", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_shell_timeout", - "to": "vm_mcp_shell_execution_bounded" + "content_sha256": "e736aba7df09418b1c16b64c6124202cf96d7c91b45a688522daa8b9dfa0fa35", + "entry_kind": "file", + "file": "rec.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 2375, + "status": "supported" }, { - "from": "check_vm_mcp_symlink_escape_rejected", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_symlink_escape_rejected", - "to": "self::test_symlink_escape_rejected" + "content_sha256": "c45a813782c5443f05224a4600572694808b69d25b6bff9951e5c3023a123a0c", + "entry_kind": "file", + "file": "repo-audit-repair/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 15239, + "status": "supported" }, { - "from": "check_vm_mcp_symlink_escape_rejected", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_symlink_escape_rejected", - "to": "vm_mcp_read_paths_confined" + "content_sha256": "3b27c19a2b671d5a9edfed24912fcbbdcb9d88cf4b5a7e6b31e732b4f3dcf907", + "entry_kind": "file", + "file": "risk-boundary-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 5778, + "status": "supported" }, { - "from": "check_vm_mcp_systemd_write_boundary", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_systemd_write_boundary", - "to": "self::test_non_root_service_keeps_hardening" + "content_sha256": "faaf097cd8b1da2bf18628a1fa9acebe4a671a20ad5d12301b20422da333a011", + "entry_kind": "file", + "file": "skill-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 8468, + "status": "supported" }, { - "from": "check_vm_mcp_systemd_write_boundary", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_systemd_write_boundary", - "to": "vm_mcp_host_write_confined" + "content_sha256": "hmmm", + "entry_kind": "output", + "file": "skill-lib_msdmd.ts", + "reader_ids": [], + "reason": "generated-collection-output", + "status": "excluded" }, { - "from": "check_vm_mcp_user_exec_non_root", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_user_exec_non_root", - "to": "self::test_user_mode_rejects_root" + "content_sha256": "a225992847b15c53803d01c25860f0ad4bc1e9cfd868d5b48750c6fc58bf0bb4", + "entry_kind": "file", + "file": "skill-usage/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 3635, + "status": "supported" }, { - "from": "check_vm_mcp_user_exec_non_root", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_user_exec_non_root", - "to": "vm_mcp_user_exec_non_root" + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "entry_kind": "file", + "file": "skill_lib/safety/repo_loto.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 15446, + "status": "supported" }, { - "from": "check_vm_mcp_workspace_write_confined", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_workspace_write_confined", - "to": "self::test_write_and_move_remain_under_root" + "content_sha256": "9b29cbb4d538080725b90b1c6a2339cea6677f88657ec145e7bfce6edfb72d0e", + "entry_kind": "file", + "file": "skills.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 28201, + "status": "supported" }, { - "from": "check_vm_mcp_workspace_write_confined", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_workspace_write_confined", - "to": "vm_mcp_workspace_writes_confined" + "content_sha256": "9f42a07170187636ea99851465a48672ad0453689effab922b5c3e14769c807c", + "entry_kind": "file", + "file": "skills/a0p-instancing/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 1115, + "status": "supported" }, { - "from": "check_vm_mcp_workspace_write_gate", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_workspace_write_gate", - "to": "self::test_write_requires_mutating_profile" + "content_sha256": "9509aeca38b6c08d5eebf0b7660bcc44a1851ab40c76ef2964d91c02bd10fc29", + "entry_kind": "file", + "file": "skills/action-calibration/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 853, + "status": "supported" }, { - "from": "check_vm_mcp_workspace_write_gate", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_vm_mcp_workspace_write_gate", - "to": "vm_mcp_workspace_writes_confined" + "content_sha256": "0865940e8b893a7f2af826de66a4920c7b4829a09efac8ec2769ea41456fe105", + "entry_kind": "file", + "file": "skills/agent-instantiation/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 1124, + "status": "supported" }, { - "from": "gonol_authority_gate", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "gonol_authority_gate", - "to": "skill-lib" + "content_sha256": "579cb259ca8c2aae1a93ef41c72cc7037b49f8ba5c226f86d2846397958849ea", + "entry_kind": "file", + "file": "skills/canon/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 670, + "status": "supported" }, { - "from": "gonol_authority_gate", - "kind": "requires", - "source_block": "MODULE_BUILD", - "source_id": "gonol_authority_gate", - "to": "active skill-lib projections" + "content_sha256": "4fd6011f147153e596415a8fc56f76c71d9fc12387e5814a14d58e785c08d7ec", + "entry_kind": "file", + "file": "skills/cap-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 686, + "status": "supported" }, { - "from": "gonol_authority_gate", - "kind": "requires", - "source_block": "MODULE_BUILD", - "source_id": "gonol_authority_gate", - "to": "char-compress/SKILL.md" + "content_sha256": "536e878e7ad79c650cb515930d3579c0c6efcd648f2aa14c551d8cfcaade53c5", + "entry_kind": "file", + "file": "skills/char-compress/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 1008, + "status": "supported" }, { - "from": "gonol_authority_gate", - "kind": "requires", - "source_block": "MODULE_BUILD", - "source_id": "gonol_authority_gate", - "to": "gonol-build/SKILL.md" + "content_sha256": "f4a240b27c3f0d01c79d4d38528c0362225d4ae3169978fb14155623a05d2b77", + "entry_kind": "file", + "file": "skills/data-visualization/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 565, + "status": "supported" }, { - "from": "interdependent_work_graph_portfolio_plan", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "interdependent_work_graph_portfolio_plan", - "to": "The-Interdependency/skill-lib maintainers" + "content_sha256": "5356ccde0cc29c3b9d34e190b969a59eb16384f6d38d0c39a61be082e6e5a5d3", + "entry_kind": "file", + "file": "skills/deps-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 700, + "status": "supported" }, { - "from": "msdmd_python_module_projection", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "msdmd_python_module_projection", - "to": "The Interdependency skill-lib" + "content_sha256": "1efb32e2960b05f7212e7792431a53c41c8525b2c294fe3aa8734e08414e7f78", + "entry_kind": "file", + "file": "skills/distributed-publication/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 1059, + "status": "supported" }, { - "from": "msdmd_python_reference_parser", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "msdmd_python_reference_parser", - "to": "The Interdependency skill-lib" + "content_sha256": "6b98243348d649298f82d12e4d10556422ea8917b529aa5476767bae35f06957", + "entry_kind": "file", + "file": "skills/doc-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 711, + "status": "supported" }, { - "from": "msdmd_typescript_reference_parser", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "msdmd_typescript_reference_parser", + "content_sha256": "1b25bc106d38e3d697923ab13951f5fb257ac84aff496c970e87c122104e9500", + "entry_kind": "file", + "file": "skills/domain-claims/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 931, + "status": "supported" + }, + { + "content_sha256": "ba980124fad706570f64f79e8549d37da7d284c6364471ef5f5cb42c05bc338d", + "entry_kind": "file", + "file": "skills/epac-selection-display/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 914, + "status": "supported" + }, + { + "content_sha256": "bc113123417f8f0cb1b57c993c24bc1763d94333d6a7677384e20dca4931d36d", + "entry_kind": "file", + "file": "skills/explore-data/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 584, + "status": "supported" + }, + { + "content_sha256": "2b09c65531ccd39a7955011e613887917e63713cb06f8327841c2a2e54216060", + "entry_kind": "file", + "file": "skills/fresh-making/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 929, + "status": "supported" + }, + { + "content_sha256": "80f641582e683bed0040c6ce3c21e19236a8534e031bc633487ca20169f6d4c2", + "entry_kind": "file", + "file": "skills/gonol-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 1048, + "status": "supported" + }, + { + "content_sha256": "6e27e3c4f3b06bd1bb5875b49ca1c29bd5db80ef2d7bce0a89f6aa6f54b7dc04", + "entry_kind": "file", + "file": "skills/interdependent-work-graph/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 814, + "status": "supported" + }, + { + "content_sha256": "df9e4a651b893da1e2395047646b3fe12f9f7acfeebb28c466092a033cdd59fe", + "entry_kind": "file", + "file": "skills/llms-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 639, + "status": "supported" + }, + { + "content_sha256": "3599cefdf7545ef5ee1383002890697577d20e2565526e8cf303b5c223dc3d39", + "entry_kind": "file", + "file": "skills/loop-eng/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 780, + "status": "supported" + }, + { + "content_sha256": "8fa8474c6ea92aba000212a9afcb687ee6d412914442f92c0de9c9fb10d008ab", + "entry_kind": "file", + "file": "skills/manifest/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 1152, + "status": "supported" + }, + { + "content_sha256": "477040eeb318d17c5d8532c1ca4245f64626c6b60d3354588753b48ef866f1a9", + "entry_kind": "file", + "file": "skills/meta-module-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 635, + "status": "supported" + }, + { + "content_sha256": "a721ce8c37f8aeccacd07f41854d154edb44695da637452aec3dbf64c6af38b3", + "entry_kind": "file", + "file": "skills/meta/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 950, + "status": "supported" + }, + { + "content_sha256": "93ad71f5b4b692e219b42eba5df07c0caba541f9d3b0fa8cd4a80d0b0945d49b", + "entry_kind": "file", + "file": "skills/msdmd/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 730, + "status": "supported" + }, + { + "content_sha256": "b9ee2c381e1f3fe330abd59758f5b5466d7bf88d58e35193a4b4f6114b5466ad", + "entry_kind": "file", + "file": "skills/owner-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 713, + "status": "supported" + }, + { + "content_sha256": "e502bfcaee33b1a6a7f30fc953e94993ad4667a4da765c70fd2323dbe2c85212", + "entry_kind": "file", + "file": "skills/plain-lens/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 1058, + "status": "supported" + }, + { + "content_sha256": "65cba655c532c341452c46d2aa4bf3182e6e4a7a17bc53ee65872395336f48f0", + "entry_kind": "file", + "file": "skills/project-incubation-graduation/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 1058, + "status": "supported" + }, + { + "content_sha256": "ff73c3f8d798f35df287b5adfdee54fa0585ac96993d0938317cff906231b551", + "entry_kind": "file", + "file": "skills/ratios/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 1081, + "status": "supported" + }, + { + "content_sha256": "dbab49c237a2e87d81adc3c47e96270664472a4b559fe9a5fa2416bd2a6bd85a", + "entry_kind": "file", + "file": "skills/repo-audit-repair/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 891, + "status": "supported" + }, + { + "content_sha256": "03494ed2a58138903ea569d663bce19de8efb27e489df67394a739caa337223c", + "entry_kind": "file", + "file": "skills/risk-boundary-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 740, + "status": "supported" + }, + { + "content_sha256": "45cafced18a804c9c3ef9a082a9deff9c52e4c641f0ea59b3ef97d33fef473e5", + "entry_kind": "file", + "file": "skills/skill-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 657, + "status": "supported" + }, + { + "content_sha256": "d7446ed118846f82fe63524e171eee599f6001447749f3f1da2d141d5a62a456", + "entry_kind": "file", + "file": "skills/skill-usage/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 602, + "status": "supported" + }, + { + "content_sha256": "4f0b660ee647329ea77900243caf737f678c959fb46d0cddcec2ba8597e55f8e", + "entry_kind": "file", + "file": "skills/sql-queries/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 581, + "status": "supported" + }, + { + "content_sha256": "7a3e6c5d07df0e4e84da48efb2d7ff38bac1ac7c83f29af10155ebb8f566b45e", + "entry_kind": "file", + "file": "skills/ssh-automation/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 815, + "status": "supported" + }, + { + "content_sha256": "f9ec13061c7003b58f49ca2f595489d3f15b40c13cc710f69dda915038864d32", + "entry_kind": "file", + "file": "skills/stack-update/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 809, + "status": "supported" + }, + { + "content_sha256": "8862fda54003b4e0c428506a472c945d8617426a261eabac5d1c111bd2b76403", + "entry_kind": "file", + "file": "skills/statistical-analysis/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 569, + "status": "supported" + }, + { + "content_sha256": "3aff88b8d87efac6833b31f4d4a5da44329f737578f6083c1864641551487976", + "entry_kind": "file", + "file": "skills/test-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 704, + "status": "supported" + }, + { + "content_sha256": "a04d14626527dd8130404c0ff49645cf4f538e0db59b695e6a5d0ca0b2879b79", + "entry_kind": "file", + "file": "skills/the-interdependency/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 741, + "status": "supported" + }, + { + "content_sha256": "1ff29ce52ad6e6796e87ec39af9ca13dbcc8dac3b52792ac107b9eef0ece2613", + "entry_kind": "file", + "file": "skills/thought-lens/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 987, + "status": "supported" + }, + { + "content_sha256": "2e2ecc7e280076510fd900d976719ecccacd13b2fead3997b8b02fc86dc5001d", + "entry_kind": "file", + "file": "skills/typed-meta-frontend/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 703, + "status": "supported" + }, + { + "content_sha256": "b08fa7f7662af281209e16343137bd94b970e29433474b0b955512f1f53e9f5d", + "entry_kind": "file", + "file": "skills/ucns-option-selection/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 977, + "status": "supported" + }, + { + "content_sha256": "76c3dc536b6fcf18aaa62a10137405e78e96e2098072cd70756fd2706cf18d44", + "entry_kind": "file", + "file": "skills/validate-data/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 601, + "status": "supported" + }, + { + "content_sha256": "bec444a3baa4f713fea1c0ed46cf8233fb95ba3c9f599d5b19a0651e95a127cc", + "entry_kind": "file", + "file": "skills/visitor-intro/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 655, + "status": "supported" + }, + { + "content_sha256": "17f6412b4492bf8564f0a56c9e8bb7189c420c18cf88ac74cfda1b3dba47271c", + "entry_kind": "file", + "file": "skills/vm-mcp/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 853, + "status": "supported" + }, + { + "content_sha256": "c28aea4e5fb25133074e2e07d5e814259838f26f1c9d452e76c53986c33e5b0f", + "entry_kind": "file", + "file": "skills/website-builder-journal/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 818, + "status": "supported" + }, + { + "content_sha256": "110164773d0f5daf458031c4464f8eeb3b1a18c96c71ed876b97c10c772dd923", + "entry_kind": "file", + "file": "sql-queries/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 12586, + "status": "supported" + }, + { + "content_sha256": "f62e9280947853eba77e2b9df22fb5a45491afd39b52f6f09dc728717ddb55c8", + "entry_kind": "file", + "file": "ssh-automation/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 19175, + "status": "supported" + }, + { + "content_sha256": "ab76d6cb5b334330e727b1edf55b86421f3c072014e48ae144bffe0fdc9f0309", + "entry_kind": "file", + "file": "ssh-automation/references/primary-sources.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 4634, + "status": "supported" + }, + { + "content_sha256": "a708557f486f638cd1204af66ea8d268c498bcd840c240f869eeb1ebace9eb1c", + "entry_kind": "file", + "file": "stack-update/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 7568, + "status": "supported" + }, + { + "content_sha256": "a4276f17940d9a8026325ef40055717be34139137a77ca63b0222df98d6229c4", + "entry_kind": "file", + "file": "statistical-analysis/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 11747, + "status": "supported" + }, + { + "content_sha256": "d50de734dbd19e9af97287952016d1263aab4b6f2e8935f2b67bc4255471ef1e", + "entry_kind": "file", + "file": "test-build/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 11728, + "status": "supported" + }, + { + "content_sha256": "dd3917c47dc9380158c4b35f8e2eaf3d01d0d5c5394c1f303580dd249884714d", + "entry_kind": "file", + "file": "tests/fixtures/distributed_publication_manifest.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 2056, + "status": "supported" + }, + { + "content_sha256": "718290b7331141391e8e02f6f1c3a18bfc1ed60fb7909b0ec3330241b42c044e", + "entry_kind": "file", + "file": "tests/frontmatter.py", + "reader_ids": [ + "python-ast" + ], + "size": 1454, + "status": "supported" + }, + { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "entry_kind": "file", + "file": "tests/test_action_calibration_skill.py", + "reader_ids": [ + "python-ast" + ], + "size": 4847, + "status": "supported" + }, + { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "entry_kind": "file", + "file": "tests/test_ai_launcher.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 3246, + "status": "supported" + }, + { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "entry_kind": "file", + "file": "tests/test_annotate_index.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 7420, + "status": "supported" + }, + { + "content_sha256": "ae6185ea8ef67eef74995cf57ac9bd0aebdf3eff1447ae2bfb80f1d055a66c2f", + "entry_kind": "file", + "file": "tests/test_char_compress_authority.py", + "reader_ids": [ + "python-ast" + ], + "size": 2208, + "status": "supported" + }, + { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "entry_kind": "file", + "file": "tests/test_collect.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 5048, + "status": "supported" + }, + { + "content_sha256": "d8b9255106d56f874064ee7dbe182c8d16fd6d9bfea3dba4390a187d97a80b7b", + "entry_kind": "file", + "file": "tests/test_collection_schema.py", + "reader_ids": [ + "python-ast" + ], + "size": 2682, + "status": "supported" + }, + { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "entry_kind": "file", + "file": "tests/test_consumer_drift.py", + "reader_ids": [ + "python-ast" + ], + "size": 12083, + "status": "supported" + }, + { + "content_sha256": "930f1cd3251d2ab7d4877699f0e89c1740a566e6757d2320d1672d0da576540d", + "entry_kind": "file", + "file": "tests/test_consumer_matrix.py", + "reader_ids": [ + "python-ast" + ], + "size": 1670, + "status": "supported" + }, + { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "entry_kind": "file", + "file": "tests/test_distributed_publication_skill.py", + "reader_ids": [ + "python-ast" + ], + "size": 5187, + "status": "supported" + }, + { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "entry_kind": "file", + "file": "tests/test_domain_claims_skill.py", + "reader_ids": [ + "python-ast" + ], + "size": 2945, + "status": "supported" + }, + { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "entry_kind": "file", + "file": "tests/test_epac_selection_display_skill.py", + "reader_ids": [ + "python-ast" + ], + "size": 5679, + "status": "supported" + }, + { + "content_sha256": "68cf19d6a44fdb3cf06d635af2e2b1615ff7f5092054bce18bf8e4068a76e549", + "entry_kind": "file", + "file": "tests/test_frontmatter.py", + "reader_ids": [ + "python-ast" + ], + "size": 1277, + "status": "supported" + }, + { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "entry_kind": "file", + "file": "tests/test_gonol_build_skill.py", + "reader_ids": [ + "python-ast" + ], + "size": 7751, + "status": "supported" + }, + { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "entry_kind": "file", + "file": "tests/test_harmonics.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 4006, + "status": "supported" + }, + { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "entry_kind": "file", + "file": "tests/test_information_design.py", + "reader_ids": [ + "python-ast" + ], + "size": 3807, + "status": "supported" + }, + { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "entry_kind": "file", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "reader_ids": [ + "python-ast" + ], + "size": 6457, + "status": "supported" + }, + { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "entry_kind": "file", + "file": "tests/test_llms_build.py", + "reader_ids": [ + "python-ast" + ], + "size": 3401, + "status": "supported" + }, + { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "entry_kind": "file", + "file": "tests/test_module_projection.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 38041, + "status": "supported" + }, + { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "entry_kind": "file", + "file": "tests/test_msdmd_native_contract_docs.py", + "reader_ids": [ + "python-ast" + ], + "size": 7286, + "status": "supported" + }, + { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "entry_kind": "file", + "file": "tests/test_native_collection.py", + "reader_ids": [ + "python-ast" + ], + "size": 12659, + "status": "supported" + }, + { + "content_sha256": "fd47c93072fd0db383b17fc4492436a7031b5bb9984f2bf1903799c4919aac61", + "entry_kind": "file", + "file": "tests/test_native_encoding_boundary.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 1298, + "status": "supported" + }, + { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "entry_kind": "file", + "file": "tests/test_native_review_closure.py", + "reader_ids": [ + "python-ast" + ], + "size": 9942, + "status": "supported" + }, + { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "entry_kind": "file", + "file": "tests/test_native_review_regressions.py", + "reader_ids": [ + "python-ast" + ], + "size": 8327, + "status": "supported" + }, + { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "entry_kind": "file", + "file": "tests/test_native_standards.py", + "reader_ids": [ + "python-ast" + ], + "size": 18407, + "status": "supported" + }, + { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "entry_kind": "file", + "file": "tests/test_org_reports.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 5983, + "status": "supported" + }, + { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "entry_kind": "file", + "file": "tests/test_project_incubation_graduation_skill.py", + "reader_ids": [ + "python-ast" + ], + "size": 6006, + "status": "supported" + }, + { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "entry_kind": "file", + "file": "tests/test_propagate_skills.py", + "reader_ids": [ + "python-ast" + ], + "size": 6615, + "status": "supported" + }, + { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "entry_kind": "file", + "file": "tests/test_ratios_check.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 2873, + "status": "supported" + }, + { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "entry_kind": "file", + "file": "tests/test_repo_audit_repair_skill.py", + "reader_ids": [ + "python-ast" + ], + "size": 5308, + "status": "supported" + }, + { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "entry_kind": "file", + "file": "tests/test_repo_loto.py", + "reader_ids": [ + "python-ast" + ], + "size": 15085, + "status": "supported" + }, + { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "entry_kind": "file", + "file": "tests/test_repo_loto_audit.py", + "reader_ids": [ + "python-ast" + ], + "size": 5484, + "status": "supported" + }, + { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "entry_kind": "file", + "file": "tests/test_schema_uri_detection.py", + "reader_ids": [ + "python-ast" + ], + "size": 3397, + "status": "supported" + }, + { + "content_sha256": "dacc6f013dbad80bb0f7ddc868bb4b5deb0f26e77e991f94614fab027acad76c", + "entry_kind": "file", + "file": "tests/test_skill_compliance.py", + "reader_ids": [ + "python-ast" + ], + "size": 321, + "status": "supported" + }, + { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "entry_kind": "file", + "file": "tests/test_skill_index_semantics.py", + "reader_ids": [ + "python-ast" + ], + "size": 3953, + "status": "supported" + }, + { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "entry_kind": "file", + "file": "tests/test_skill_lib_drift.py", + "reader_ids": [ + "python-ast" + ], + "size": 2327, + "status": "supported" + }, + { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "entry_kind": "file", + "file": "tests/test_skill_library.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 3720, + "status": "supported" + }, + { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "entry_kind": "file", + "file": "tests/test_skill_specs.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 7406, + "status": "supported" + }, + { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "entry_kind": "file", + "file": "tests/test_skill_usage.py", + "reader_ids": [ + "python-ast" + ], + "size": 2015, + "status": "supported" + }, + { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "entry_kind": "file", + "file": "tests/test_ssh_automation_skill.py", + "reader_ids": [ + "python-ast" + ], + "size": 5037, + "status": "supported" + }, + { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "entry_kind": "file", + "file": "tests/test_the_interdependency_skill.py", + "reader_ids": [ + "python-ast" + ], + "size": 3926, + "status": "supported" + }, + { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "entry_kind": "file", + "file": "tests/test_ucns_option_selection_skill.py", + "reader_ids": [ + "python-ast" + ], + "size": 3023, + "status": "supported" + }, + { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "entry_kind": "file", + "file": "tests/test_universal_parser.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 13280, + "status": "supported" + }, + { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "entry_kind": "file", + "file": "tests/test_visualize.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 6582, + "status": "supported" + }, + { + "content_sha256": "52332c589708425765027d2e8ca94953e006e5400fd0d289095793fc184bcd2f", + "entry_kind": "file", + "file": "tests/test_vm_mcp.py", + "reader_ids": [ + "python-ast" + ], + "size": 711, + "status": "supported" + }, + { + "content_sha256": "ea04b94251a567ced5bb336316b17e30f9647047adcccc89b3a6ecdac67f7c0b", + "entry_kind": "file", + "file": "tests/test_website_builder_journal_skill.py", + "reader_ids": [ + "python-ast" + ], + "size": 1977, + "status": "supported" + }, + { + "content_sha256": "d3a92b21eb332d68304ba0a29087df9d5c002053e30a04097ac8aa7612525da5", + "entry_kind": "file", + "file": "the-interdependency/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 20332, + "status": "supported" + }, + { + "content_sha256": "bb425468da1a053a32cb89a3d85d4e4d6e7fc953c70610c6c886c028e3bc63df", + "entry_kind": "file", + "file": "thought-lens/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 14719, + "status": "supported" + }, + { + "content_sha256": "97518234e1d6ff442262d993f5d1393f64540bb4cb256ecc31a7421e05b82eda", + "entry_kind": "file", + "file": "thought-lens/fixtures.json", + "reader_ids": [ + "json-stdlib", + "metadata-standards" + ], + "size": 4033, + "status": "supported" + }, + { + "content_sha256": "c693e801e8c73a471aef61a54f63b900d965423e771a16e39fe8a47fceef9712", + "entry_kind": "file", + "file": "tools/README.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 8518, + "status": "supported" + }, + { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "entry_kind": "file", + "file": "tools/aggregate_org_rec.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 9397, + "status": "supported" + }, + { + "content_sha256": "b11bce0772f12eb320c52fc2abf81b4eaae2ba6a12b70a099cf13c0d6414da3e", + "entry_kind": "file", + "file": "tools/ai.sh", + "reader_ids": [ + "shell-static", + "msdmd-ratios" + ], + "size": 9904, + "status": "supported" + }, + { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "entry_kind": "file", + "file": "tools/build_codex_plugin_skills.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 4992, + "status": "supported" + }, + { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "entry_kind": "file", + "file": "tools/char_compress_check.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 7023, + "status": "supported" + }, + { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "entry_kind": "file", + "file": "tools/check_consumer_drift.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 13099, + "status": "supported" + }, + { + "content_sha256": "1875f8c9e922642b3707632e93282efe6390b5ae29ab9d1f1d283246ba7868ca", + "entry_kind": "file", + "file": "tools/check_gonol_authority.sh", + "reader_ids": [ + "shell-static", + "msdmd-ratios" + ], + "size": 2880, + "status": "supported" + }, + { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "entry_kind": "file", + "file": "tools/check_skill_compliance.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 5603, + "status": "supported" + }, + { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "entry_kind": "file", + "file": "tools/check_skill_lib_drift.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 8938, + "status": "supported" + }, + { + "content_sha256": "534f315eb67c9657683868c37c8e348eb60f40d8bdf4fcc95c6ac27833fadce1", + "entry_kind": "file", + "file": "tools/install_ai.sh", + "reader_ids": [ + "shell-static", + "msdmd-ratios" + ], + "size": 2145, + "status": "supported" + }, + { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "entry_kind": "file", + "file": "tools/org_ratio_compare.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 17164, + "status": "supported" + }, + { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "entry_kind": "file", + "file": "tools/propagate_skills.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 10143, + "status": "supported" + }, + { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "entry_kind": "file", + "file": "tools/skill_usage.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 6782, + "status": "supported" + }, + { + "content_sha256": "047ec94675d6e44da94ed325c62216d0c45d78a0485cdcdd13049dd23500cc29", + "entry_kind": "file", + "file": "typed-meta-frontend/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 9280, + "status": "supported" + }, + { + "content_sha256": "1572833b56ff8f1af41fb6f01bb3e91c300cf825a326900d272fcb4ba26bd3cb", + "entry_kind": "file", + "file": "ucns-option-selection/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 9963, + "status": "supported" + }, + { + "content_sha256": "256a1a65b55e66e6f3e05ee4547f69c7c3443b9ddc1d40100f132660c7af108b", + "entry_kind": "file", + "file": "validate-data/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 16235, + "status": "supported" + }, + { + "content_sha256": "cb80912a7e956a888f6a7ee074cbdc61709962f39be1bd2db44066929b7657c3", + "entry_kind": "file", + "file": "visitor-intro/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 8026, + "status": "supported" + }, + { + "content_sha256": "7b6d81cbefe4aaf62c14afd942e5399de34c84c53838375af5271f04a4525c64", + "entry_kind": "file", + "file": "vm-mcp/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 14093, + "status": "supported" + }, + { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "entry_kind": "file", + "file": "vm-mcp/admin_broker.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 11772, + "status": "supported" + }, + { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "entry_kind": "file", + "file": "vm-mcp/admin_client.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 2974, + "status": "supported" + }, + { + "content_sha256": "55b57034b88fd2d4237286d20b007d38853c34389ef1c0d8a35647c288a6a64c", + "entry_kind": "file", + "file": "vm-mcp/install.sh", + "reader_ids": [ + "shell-static", + "msdmd-ratios" + ], + "size": 5526, + "status": "supported" + }, + { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "entry_kind": "file", + "file": "vm-mcp/policy.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 17434, + "status": "supported" + }, + { + "content_sha256": "32cb60f4c5a3643cee4294bf11c97bd618e51043e06be0c8c9f69cf2605a2bf7", + "entry_kind": "file", + "file": "vm-mcp/requirements.txt", + "reader_ids": [ + "python-requirements" + ], + "size": 159, + "status": "supported" + }, + { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "entry_kind": "file", + "file": "vm-mcp/server.py", + "reader_ids": [ + "python-ast", + "msdmd-ratios" + ], + "size": 7442, + "status": "supported" + }, + { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "entry_kind": "file", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "reader_ids": [ + "systemd-unit" + ], + "size": 572, + "status": "supported" + }, + { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "entry_kind": "file", + "file": "vm-mcp/systemd/vm-mcp.service", + "reader_ids": [ + "systemd-unit" + ], + "size": 1147, + "status": "supported" + }, + { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "entry_kind": "file", + "file": "vm-mcp/tests/test_admin_broker.py", + "reader_ids": [ + "python-ast" + ], + "size": 3340, + "status": "supported" + }, + { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "entry_kind": "file", + "file": "vm-mcp/tests/test_assets.py", + "reader_ids": [ + "python-ast" + ], + "size": 3676, + "status": "supported" + }, + { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "entry_kind": "file", + "file": "vm-mcp/tests/test_policy.py", + "reader_ids": [ + "python-ast" + ], + "size": 8474, + "status": "supported" + }, + { + "content_sha256": "fe70827ff824dfa5a35c18bd93663e46f7a353812e22cbb49c1beb537eef9d83", + "entry_kind": "file", + "file": "website-builder-journal/README.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 343, + "status": "supported" + }, + { + "content_sha256": "e0cf8442a8f6a9f8aa9dcb7c811f8f726bfb24029944069d8a2b54cf3ce2c97b", + "entry_kind": "file", + "file": "website-builder-journal/SKILL.md", + "reader_ids": [ + "markdown-frontmatter" + ], + "size": 5630, + "status": "supported" + } + ], + "edges": [ + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#block/MODULE_BUILD/interdependent_work_graph_portfolio_plan", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "interdependent_work_graph_portfolio_plan", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#block/MODULE_BUILD/interdependent_work_graph_portfolio_plan", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "The-Interdependency/skill-lib maintainers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:dataclasses" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tomllib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#block/CAPABILITIES/repo_collection_generator", + "kind": "exposes", + "source_block": "CAPABILITIES", + "source_entry_id": "repo_collection_generator", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#block/CAPABILITIES/repo_collection_generator", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#block/CAPABILITIES/repo_collection_generator", + "kind": "exposes", + "source_block": "CAPABILITIES", + "source_entry_id": "repo_collection_generator", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#block/CAPABILITIES/repo_collection_generator", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "collection_errors" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#block/CAPABILITIES/repo_collection_generator", + "kind": "exposes", + "source_block": "CAPABILITIES", + "source_entry_id": "repo_collection_generator", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#block/CAPABILITIES/repo_collection_generator", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "render_typescript" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#block/MODULE_BUILD/msdmd_collection_generator", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "msdmd_collection_generator", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#block/MODULE_BUILD/msdmd_collection_generator", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "The Interdependency skill-lib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:collections" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:collections" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:fnmatch" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:io" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:stat" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tokenize" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:urllib.parse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/JsonPrimitive%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/JsonValue%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdBlockName%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollection%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclaration%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdge%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdFieldMap%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGap%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV1%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV2%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/defineMsdmdCollection%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/defineMsdmdCollectionV2%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/mergeMsdmdFactChunks%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:decimal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:math" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:urllib.parse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:xml.etree.ElementTree" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:yaml" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:importlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tree_sitter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tree_sitter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CAPABILITIES/python_module_metadata_projection", + "kind": "exposes", + "source_block": "CAPABILITIES", + "source_entry_id": "python_module_metadata_projection", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CAPABILITIES/python_module_metadata_projection", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "Python symbol identities" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CAPABILITIES/python_module_metadata_projection", + "kind": "exposes", + "source_block": "CAPABILITIES", + "source_entry_id": "python_module_metadata_projection", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CAPABILITIES/python_module_metadata_projection", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "deterministic JSONL projection" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CAPABILITIES/python_module_metadata_projection", + "kind": "exposes", + "source_block": "CAPABILITIES", + "source_entry_id": "python_module_metadata_projection", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CAPABILITIES/python_module_metadata_projection", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "freshness key" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CAPABILITIES/python_module_metadata_projection", + "kind": "exposes", + "source_block": "CAPABILITIES", + "source_entry_id": "python_module_metadata_projection", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CAPABILITIES/python_module_metadata_projection", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "native docstrings" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CAPABILITIES/python_module_metadata_projection", + "kind": "exposes", + "source_block": "CAPABILITIES", + "source_entry_id": "python_module_metadata_projection", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CAPABILITIES/python_module_metadata_projection", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "structurally attached comments" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/MODULE_BUILD/msdmd_python_module_projection", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "msdmd_python_module_projection", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/MODULE_BUILD/msdmd_python_module_projection", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "The Interdependency skill-lib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:ast" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:codecs" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:dataclasses" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tokenize" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:ast" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.module_projection" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.module_projection" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tokenize" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:docstring_parser" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/package.json#subject/document/msdmd%2Fpackage.json", + "kind": "depends_on:runtime", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "npm-package:typescript" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#block/MODULE_BUILD/msdmd_python_reference_parser", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "msdmd_python_reference_parser", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#block/MODULE_BUILD/msdmd_python_reference_parser", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "The Interdependency skill-lib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#block/MODULE_BUILD/msdmd_typescript_reference_parser", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "msdmd_typescript_reference_parser", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#block/MODULE_BUILD/msdmd_typescript_reference_parser", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "The Interdependency skill-lib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/COMMENT_MARKERS%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/Entry%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/RATIO_IDS%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/WalkOptions%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/markerFor%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseFile%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatiosFile%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "exports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree%230" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "import", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "ecma-module:node:fs" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "kind": "import", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "ecma-module:node:path" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#block/MODULE_BUILD/msdmd_native_reader_registry", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "msdmd_native_reader_registry", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#block/MODULE_BUILD/msdmd_native_reader_registry", + "standing": "declared", + "target_resolution": "external-or-unresolved", "to": "The Interdependency skill-lib" }, { - "from": "org_ratio_comparison_runner", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "org_ratio_comparison_runner", - "to": "Codex" + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:collections" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:datetime" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:functools" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:io" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:math" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.grammar_code" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.native_code" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.native_code" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.standards" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:shlex" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tokenize" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tomllib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:urllib.parse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:xml.etree.ElementTree" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/msdmd%2Frequirements.txt", + "kind": "depends_on:runtime-or-unresolved", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-package:PyYAML" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/msdmd%2Frequirements.txt", + "kind": "depends_on:runtime-or-unresolved", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-package:docstring-parser" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/msdmd%2Frequirements.txt", + "kind": "depends_on:runtime-or-unresolved", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-package:tree-sitter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/msdmd%2Frequirements.txt", + "kind": "depends_on:runtime-or-unresolved", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-package:tree-sitter-c" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/msdmd%2Frequirements.txt", + "kind": "depends_on:runtime-or-unresolved", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-package:tree-sitter-cpp" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/msdmd%2Frequirements.txt", + "kind": "depends_on:runtime-or-unresolved", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-package:tree-sitter-java" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/msdmd%2Frequirements.txt", + "kind": "depends_on:runtime-or-unresolved", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-package:tree-sitter-rust" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:base64" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tomllib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/main", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#block/MODULE_BUILD/ratios_harmonic_math", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "ratios_harmonic_math", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#block/MODULE_BUILD/ratios_harmonic_math", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "The Interdependency" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:math" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:random" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#block/MODULE_BUILD/ratios_harmonic_explorer", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "ratios_harmonic_explorer", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#block/MODULE_BUILD/ratios_harmonic_explorer", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "The Interdependency" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#block/MODULE_BUILD/ratios_harmonic_explorer", + "kind": "requires", + "source_block": "MODULE_BUILD", + "source_entry_id": "ratios_harmonic_explorer", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#block/MODULE_BUILD/ratios_harmonic_explorer", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#block/MODULE_BUILD/ratios_harmonic_math" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:annotate_index" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:collections" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:harmonic_math" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:harmonic_math" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:harmonic_math" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:harmonic_math" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_load_semantic_collection", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/MODULE_BUILD/repo_mutation_gate", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "repo_mutation_gate", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/MODULE_BUILD/repo_mutation_gate", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "Way Seer Erin" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:fnmatch" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:time" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:uuid" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_commit", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_digest", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/frontmatter.py#subject/module/tests%2Ffrontmatter.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/frontmatter.py#subject/module/tests%2Ffrontmatter.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:frontmatter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:annotate_index" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/module/tests%2Ftest_char_compress_authority.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/module/tests%2Ftest_char_compress_authority.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:importlib.util" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/module/tests%2Ftest_consumer_matrix.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/module/tests%2Ftest_consumer_matrix.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/module/tests%2Ftest_consumer_matrix.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:frontmatter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:frontmatter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:frontmatter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:frontmatter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:frontmatter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:harmonics" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:math" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:importlib.util" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:importlib.util" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:llms.build" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:llms.build" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:llms.build" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_freshness_binds_source_and_reader", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_module_projection_freshness_binds_source_and_reader", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_freshness_binds_source_and_reader", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_freshness_key_changes_with_source_or_reader" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_freshness_binds_source_and_reader", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_module_projection_freshness_binds_source_and_reader", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_freshness_binds_source_and_reader", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CONTRACTS/module_projection_freshness_binds_source_and_reader" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_freshness_binds_source_and_reader", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_module_projection_freshness_binds_source_and_reader", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_freshness_binds_source_and_reader", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_line_shift_stability", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_module_projection_line_shift_stability", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_line_shift_stability", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_line_insertions_preserve_symbol_identity_and_attachment" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_line_shift_stability", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_module_projection_line_shift_stability", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_line_shift_stability", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CONTRACTS/module_projection_line_shift_stability" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_line_shift_stability", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_module_projection_line_shift_stability", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_line_shift_stability", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_never_executes_source", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_module_projection_never_executes_source", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_never_executes_source", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_projection_does_not_execute_inspected_source" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_never_executes_source", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_module_projection_never_executes_source", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_never_executes_source", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#block/CONTRACTS/module_projection_never_executes_source" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_never_executes_source", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_module_projection_never_executes_source", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#block/CHECKS/check_module_projection_never_executes_source", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:ast" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.module_projection" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.module_projection" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.module_projection" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.module_projection" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.module_projection" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.module_projection" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.module_projection" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:llms" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.visualize" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.build_codex_plugin_skills" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.build_codex_plugin_skills" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest.mock" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest.mock" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:base64" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.module_projection" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.readers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest.mock" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.visualize" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_oddities_visible", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_org_ratio_oddities_visible", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_oddities_visible", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_ratio_report_lists_low_coverage_oddity" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_oddities_visible", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_org_ratio_oddities_visible", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_oddities_visible", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#block/CONTRACTS/org_ratio_oddities_visible" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_oddities_visible", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_org_ratio_oddities_visible", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_oddities_visible", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_oddities_visible", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_org_ratio_oddities_visible", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_oddities_visible", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_skips_vendored_skills", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_org_ratio_skips_vendored_skills", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_skips_vendored_skills", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_ratio_metrics_skip_vendored_agents" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_skips_vendored_skills", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_org_ratio_skips_vendored_skills", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_skips_vendored_skills", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#block/CONTRACTS/org_ratio_skips_vendored_skills" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_skips_vendored_skills", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_org_ratio_skips_vendored_skills", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_skips_vendored_skills", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_skips_vendored_skills", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_org_ratio_skips_vendored_skills", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_ratio_skips_vendored_skills", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_append_only", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_append_only", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_append_only", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_aggregate_append_preserves_existing_content" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_append_only", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_append_only", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_append_only", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#block/CONTRACTS/org_rec_append_only" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_append_only", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_append_only", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_append_only", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_append_only", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_append_only", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_append_only", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_missing_repo_visible", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_missing_repo_visible", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_missing_repo_visible", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_aggregate_lists_missing_rec_files" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_missing_repo_visible", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_missing_repo_visible", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_missing_repo_visible", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#block/CONTRACTS/org_rec_missing_repo_visible" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_missing_repo_visible", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_missing_repo_visible", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_missing_repo_visible", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_missing_repo_visible", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_missing_repo_visible", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_missing_repo_visible", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_remaining_fallback", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_remaining_fallback", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_remaining_fallback", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_aggregate_uses_remaining_when_latest_block_has_no_recommendations" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_remaining_fallback", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_remaining_fallback", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_remaining_fallback", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#block/CONTRACTS/org_rec_remaining_fallback" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_remaining_fallback", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_remaining_fallback", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_remaining_fallback", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_remaining_fallback", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_org_rec_remaining_fallback", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#block/CHECKS/check_org_rec_remaining_fallback", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:aggregate_org_rec" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:org_ratio_compare" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:frontmatter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:importlib.util" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest.mock" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:ratios_check" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:frontmatter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_clear_is_empty_commit", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_clear_is_empty_commit", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_clear_is_empty_commit", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_clear_is_empty_commit" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_clear_is_empty_commit", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_clear_is_empty_commit", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_clear_is_empty_commit", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_clear_is_empty_commit" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_clear_is_empty_commit", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_clear_is_empty_commit", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_clear_is_empty_commit", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "git" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_clear_is_empty_commit", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_clear_is_empty_commit", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_clear_is_empty_commit", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_clear_is_empty_commit", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_clear_is_empty_commit", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_clear_is_empty_commit", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_close_deletes_tag", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_close_deletes_tag", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_close_deletes_tag", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_close_deletes_tag" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_close_deletes_tag", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_close_deletes_tag", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_close_deletes_tag", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_close_deletes_tag" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_close_deletes_tag", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_close_deletes_tag", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_close_deletes_tag", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "git" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_close_deletes_tag", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_close_deletes_tag", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_close_deletes_tag", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_close_deletes_tag", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_close_deletes_tag", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_close_deletes_tag", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_latest_test_wins", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_latest_test_wins", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_latest_test_wins", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_latest_test_wins" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_latest_test_wins", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_latest_test_wins", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_latest_test_wins", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_latest_test_wins" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_latest_test_wins", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_latest_test_wins", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_latest_test_wins", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "git" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_latest_test_wins", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_latest_test_wins", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_latest_test_wins", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_latest_test_wins", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_latest_test_wins", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_latest_test_wins", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_one_commit_per_session", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_one_commit_per_session", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_one_commit_per_session", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_one_commit_per_session" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_one_commit_per_session", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_one_commit_per_session", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_one_commit_per_session", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_one_commit_per_session" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_one_commit_per_session", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_one_commit_per_session", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_one_commit_per_session", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "git" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_one_commit_per_session", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_one_commit_per_session", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_one_commit_per_session", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_one_commit_per_session", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_one_commit_per_session", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_one_commit_per_session", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_open_never_dirties", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_open_never_dirties", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_open_never_dirties", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_open_never_dirties" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_open_never_dirties", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_open_never_dirties", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_open_never_dirties", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_open_never_dirties" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_open_never_dirties", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_open_never_dirties", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_open_never_dirties", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "git" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_open_never_dirties", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_open_never_dirties", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_open_never_dirties", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_open_never_dirties", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_open_never_dirties", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_open_never_dirties", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scar_blocks_work", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_scar_blocks_work", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scar_blocks_work", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_scar_blocks_work" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scar_blocks_work", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_scar_blocks_work", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scar_blocks_work", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_scar_blocks_work" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scar_blocks_work", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_scar_blocks_work", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scar_blocks_work", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "git" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scar_blocks_work", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_scar_blocks_work", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scar_blocks_work", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scar_blocks_work", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_scar_blocks_work", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scar_blocks_work", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scope_enforced", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_scope_enforced", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scope_enforced", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_scope_enforced" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scope_enforced", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_scope_enforced", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scope_enforced", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#block/CONTRACTS/loto_scope_enforced" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scope_enforced", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_scope_enforced", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scope_enforced", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "git" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scope_enforced", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_scope_enforced", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scope_enforced", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "posix_shell" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scope_enforced", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_scope_enforced", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/CHECKS/check_scope_enforced", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/MODULE_BUILD/repo_loto_evidence", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "repo_loto_evidence", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#block/MODULE_BUILD/repo_loto_evidence", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "Way Seer Erin" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:shutil" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:signal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:contextlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:importlib.util" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:io" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.formats" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/module/tests%2Ftest_skill_compliance.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/module/tests%2Ftest_skill_compliance.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.check_skill_compliance" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/module/tests%2Ftest_skill_compliance.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:frontmatter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.build_codex_plugin_skills" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.check_skill_lib_drift" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.check_skill_lib_drift" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.check_skill_lib_drift" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.check_skill_lib_drift" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.check_skill_lib_drift" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:frontmatter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.skill_usage" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.skill_usage" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.skill_usage" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.skill_usage" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.skill_usage" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.skill_usage" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.skill_usage" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/module/tests%2Ftest_ssh_automation_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/module/tests%2Ftest_ssh_automation_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/module/tests%2Ftest_ssh_automation_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:frontmatter" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_python_numeric_field_contract", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_msdmd_python_numeric_field_contract", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_python_numeric_field_contract", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_parser_field_contract" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_python_numeric_field_contract", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_msdmd_python_numeric_field_contract", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_python_numeric_field_contract", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#block/CONTRACTS/msdmd_python_parser_preserves_field_names" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_python_numeric_field_contract", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_msdmd_python_numeric_field_contract", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_python_numeric_field_contract", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_typescript_numeric_field_contract", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_msdmd_typescript_numeric_field_contract", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_typescript_numeric_field_contract", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_typescript_parser_field_contract" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_typescript_numeric_field_contract", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_msdmd_typescript_numeric_field_contract", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_typescript_numeric_field_contract", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#block/CONTRACTS/msdmd_typescript_parser_preserves_field_names" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_typescript_numeric_field_contract", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_msdmd_typescript_numeric_field_contract", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_typescript_numeric_field_contract", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "node24" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_typescript_numeric_field_contract", + "kind": "requires", + "source_block": "CHECKS", + "source_entry_id": "check_msdmd_typescript_numeric_field_contract", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#block/CHECKS/check_msdmd_typescript_numeric_field_contract", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "python3" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.parsers.universal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.collect" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.visualize" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.visualize" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:msdmd.visualize" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:test_assets" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:test_policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#block/MODULE_BUILD/org_rec_aggregation_runner", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "org_rec_aggregation_runner", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#block/MODULE_BUILD/org_rec_aggregation_runner", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "Codex" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:dataclasses" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:datetime" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:datetime" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#block/MODULE_BUILD/skill_lib_ai_launcher", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "skill_lib_ai_launcher", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#block/MODULE_BUILD/skill_lib_ai_launcher", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "skill-lib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#block/MODULE_BUILD/skill_lib_ai_launcher", + "kind": "requires", + "source_block": "MODULE_BUILD", + "source_entry_id": "skill_lib_ai_launcher", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#block/MODULE_BUILD/skill_lib_ai_launcher", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "local bash + ssh; remote bash + tmux; optional remote grok/codex/deepcodei CLIs" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:shutil" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:dataclasses" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:dataclasses" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:dataclasses" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#block/MODULE_BUILD/gonol_authority_gate", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "gonol_authority_gate", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#block/MODULE_BUILD/gonol_authority_gate", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "skill-lib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#block/MODULE_BUILD/gonol_authority_gate", + "kind": "requires", + "source_block": "MODULE_BUILD", + "source_entry_id": "gonol_authority_gate", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#block/MODULE_BUILD/gonol_authority_gate", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "active skill-lib projections" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#block/MODULE_BUILD/gonol_authority_gate", + "kind": "requires", + "source_block": "MODULE_BUILD", + "source_entry_id": "gonol_authority_gate", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#block/MODULE_BUILD/gonol_authority_gate", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "char-compress/SKILL.md" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#block/MODULE_BUILD/gonol_authority_gate", + "kind": "requires", + "source_block": "MODULE_BUILD", + "source_entry_id": "gonol_authority_gate", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#block/MODULE_BUILD/gonol_authority_gate", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "gonol-build/SKILL.md" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:dataclasses" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:build_codex_plugin_skills" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:collections" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:dataclasses" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tools.build_codex_plugin_skills" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/llms_drift_finding", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:llms.build" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/llms_drift_finding", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:llms.build" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#block/MODULE_BUILD/skill_lib_ai_installer", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "skill_lib_ai_installer", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#block/MODULE_BUILD/skill_lib_ai_installer", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "skill-lib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#block/MODULE_BUILD/skill_lib_ai_installer", + "kind": "requires", + "source_block": "MODULE_BUILD", + "source_entry_id": "skill_lib_ai_installer", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#block/MODULE_BUILD/skill_lib_ai_installer", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "bash" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#block/MODULE_BUILD/org_ratio_comparison_runner", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "org_ratio_comparison_runner", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#block/MODULE_BUILD/org_ratio_comparison_runner", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "Codex" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:dataclasses" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:dataclasses" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:datetime" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:datetime" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:statistics" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:re" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:shutil" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:argparse" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:datetime" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:datetime" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/BOUNDARIES/vm_mcp_admin_broker_root_boundary", + "kind": "owns", + "source_block": "BOUNDARIES", + "source_entry_id": "vm_mcp_admin_broker_root_boundary", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/BOUNDARIES/vm_mcp_admin_broker_root_boundary", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "skill-lib vm-mcp maintainers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/MODULE_BUILD/vm_mcp_personal_console_broker", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "vm_mcp_personal_console_broker", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/MODULE_BUILD/vm_mcp_personal_console_broker", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "skill-lib vm-mcp maintainers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:grp" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:hashlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pwd" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:selectors" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:signal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:socket" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:struct" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:sys" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:time" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:uuid" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#block/BOUNDARIES/vm_mcp_admin_client_socket_boundary", + "kind": "owns", + "source_block": "BOUNDARIES", + "source_entry_id": "vm_mcp_admin_client_socket_boundary", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#block/BOUNDARIES/vm_mcp_admin_client_socket_boundary", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "skill-lib vm-mcp maintainers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#block/MODULE_BUILD/vm_mcp_admin_client", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "vm_mcp_admin_client", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#block/MODULE_BUILD/vm_mcp_admin_client", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "skill-lib vm-mcp maintainers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:json" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:socket" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:dataclasses" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pwd" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:selectors" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:shutil" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:signal" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:socket" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:subprocess" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:time" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/broker_exec", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:admin_client" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/requirements.txt#subject/requirements-document/vm-mcp%2Frequirements.txt", + "kind": "depends_on:runtime-or-unresolved", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-package:mcp" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#block/MODULE_BUILD/vm_mcp_control_plane", + "kind": "owns", + "source_block": "MODULE_BUILD", + "source_entry_id": "vm_mcp_control_plane", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#block/MODULE_BUILD/vm_mcp_control_plane", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "skill-lib vm-mcp maintainers" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:mcp.server" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:mcp.types" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:typing" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_admin_broker_peer_verified", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_admin_broker_peer_verified", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_admin_broker_peer_verified", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_serve_source_uses_peer_credentials" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_admin_broker_peer_verified", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_admin_broker_peer_verified", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_admin_broker_peer_verified", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/CONTRACTS/vm_mcp_admin_broker_peer_verified" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_admin_exec_explicit_root", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_admin_exec_explicit_root", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_admin_exec_explicit_root", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_admin_mode_selects_root" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_admin_exec_explicit_root", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_admin_exec_explicit_root", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_admin_exec_explicit_root", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/CONTRACTS/vm_mcp_admin_exec_explicit_root" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_broker_execution_bounded", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_broker_execution_bounded", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_broker_execution_bounded", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_admin_execution_timeout_is_bounded_when_root" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_broker_execution_bounded", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_broker_execution_bounded", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_broker_execution_bounded", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/CONTRACTS/vm_mcp_broker_execution_bounded" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_user_exec_non_root", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_user_exec_non_root", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_user_exec_non_root", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_user_mode_rejects_root" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_user_exec_non_root", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_user_exec_non_root", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#block/CHECKS/check_vm_mcp_user_exec_non_root", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#block/CONTRACTS/vm_mcp_user_exec_non_root" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:admin_broker" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pwd" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest.mock" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_admin_execution_timeout_is_bounded_when_root", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_loopback_config", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_loopback_config", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_loopback_config", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_server_binds_loopback_only" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_loopback_config", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_loopback_config", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_loopback_config", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#block/CONTRACTS/vm_mcp_loopback_only" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_metadata_denial", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_metadata_denial", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_metadata_denial", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_systemd_blocks_cloud_metadata_address" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_metadata_denial", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_metadata_denial", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_metadata_denial", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#block/CONTRACTS/vm_mcp_metadata_credentials_blocked" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_personal_console_root_separate", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_personal_console_root_separate", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_personal_console_root_separate", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_personal_console_uses_separate_root_broker" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_personal_console_root_separate", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_personal_console_root_separate", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_personal_console_root_separate", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#block/CONTRACTS/vm_mcp_personal_console_root_separate" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_systemd_write_boundary", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_systemd_write_boundary", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_systemd_write_boundary", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_non_root_service_keeps_hardening" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_systemd_write_boundary", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_systemd_write_boundary", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#block/CHECKS/check_vm_mcp_systemd_write_boundary", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#block/CONTRACTS/vm_mcp_host_write_confined" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_environment_sanitized", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_environment_sanitized", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_environment_sanitized", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_shell_does_not_inherit_unrelated_environment" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_environment_sanitized", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_environment_sanitized", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_environment_sanitized", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_credentials_not_inherited" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_listing_symlink_not_followed", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_listing_symlink_not_followed", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_listing_symlink_not_followed", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_listing_does_not_follow_symlink_metadata" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_listing_symlink_not_followed", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_listing_symlink_not_followed", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_listing_symlink_not_followed", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_listing_symlinks_not_followed" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_output_bounded", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_output_bounded", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_output_bounded", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_read_text_is_bounded" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_output_bounded", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_output_bounded", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_output_bounded", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_output_bounded" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_parent_escape_rejected", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_parent_escape_rejected", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_parent_escape_rejected", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_parent_escape_rejected" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_parent_escape_rejected", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_parent_escape_rejected", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_parent_escape_rejected", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_read_paths_confined" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_personal_console_gate", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_personal_console_gate", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_personal_console_gate", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_broker_exec_requires_personal_console" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_personal_console_gate", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_personal_console_gate", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_personal_console_gate", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_personal_console_explicit" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_profile_default_read_only", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_profile_default_read_only", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_profile_default_read_only", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_default_profile_is_read_only" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_profile_default_read_only", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_profile_default_read_only", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_profile_default_read_only", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_profile_default_read_only" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_cwd_escape_rejected", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_shell_cwd_escape_rejected", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_cwd_escape_rejected", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_shell_cwd_escape_rejected" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_cwd_escape_rejected", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_shell_cwd_escape_rejected", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_cwd_escape_rejected", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_shell_cwd_confined" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_output_bounded", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_shell_output_bounded", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_output_bounded", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_shell_output_is_bounded_while_draining" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_output_bounded", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_shell_output_bounded", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_output_bounded", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_shell_execution_bounded" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_timeout", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_shell_timeout", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_timeout", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_shell_timeout_is_enforced" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_timeout", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_shell_timeout", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_shell_timeout", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_shell_execution_bounded" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_symlink_escape_rejected", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_symlink_escape_rejected", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_symlink_escape_rejected", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_symlink_escape_rejected" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_symlink_escape_rejected", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_symlink_escape_rejected", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_symlink_escape_rejected", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_read_paths_confined" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_workspace_write_confined", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_workspace_write_confined", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_workspace_write_confined", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_write_and_move_remain_under_root" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_workspace_write_confined", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_workspace_write_confined", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_workspace_write_confined", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_workspace_writes_confined" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_workspace_write_gate", + "kind": "calls", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_workspace_write_gate", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_workspace_write_gate", + "standing": "declared", + "target_resolution": "external-or-unresolved", + "to": "self::test_write_requires_mutating_profile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_workspace_write_gate", + "kind": "claims_proves", + "source_block": "CHECKS", + "source_entry_id": "check_vm_mcp_workspace_write_gate", + "source_id": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#block/CHECKS/check_vm_mcp_workspace_write_gate", + "standing": "declared", + "target_resolution": "resolved-unique-entry-id", + "to": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#block/CONTRACTS/vm_mcp_workspace_writes_confined" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:__future__" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:os" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:pathlib" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:policy" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:tempfile" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:time" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest" + }, + { + "from": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "kind": "imports", + "standing": "syntactically-observed", + "target_resolution": "external-or-unresolved", + "to": "python-module:unittest.mock" + } + ], + "facts": mergeMsdmdFactChunks( + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.claude-plugin/marketplace.json#subject/document/.claude-plugin%2Fmarketplace.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "claude.plugin-marketplace", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "name": "skill-lib", + "owner": { + "email": "wayseer@interdependentway.org", + "name": "The Interdependency" + }, + "plugins": [ + { + "category": "governance", + "description": "Portable governance skills with runnable MSDMD block-only helpers and drift gates, plus a native-first metadata ingestion contract whose native readers remain implementation work. Block syntax supplements metadata already expressed by code, manifests, schemas, documentation, ownership rules, and tooling; unsupported inputs stay visible as hmmm.", + "name": "skill-lib", + "skills": [ + "./" + ], + "source": "./", + "strict": false, + "tags": [ + "msdmd", + "governance", + "metadata", + "compliance", + "drift-gates", + "skills", + "data" + ] + } + ] + } + }, + "origin": "native", + "source": { + "content_sha256": "2291d1897b60f1b9c56050d855eb287c5984fd18f94124d9c3bc016951c3be80", + "file": ".claude-plugin/marketplace.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.claude-plugin/marketplace.json#subject/document/.claude-plugin%2Fmarketplace.json", + "identity": ".claude-plugin/marketplace.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.codex-plugin/plugin.json#subject/document/.codex-plugin%2Fplugin.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "codex.plugin-manifest", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "author": { + "name": "The Interdependency", + "url": "https://github.com/The-Interdependency" + }, + "description": "The Interdependency skill library with evidence-bearing usage maturity.", + "homepage": "https://github.com/The-Interdependency/skill-lib", + "interface": { + "capabilities": [ + "Read", + "Write" + ], + "category": "Developer Tools", + "defaultPrompt": "Show the skill-lib maturity spectrum.", + "developerName": "The Interdependency", + "displayName": "The Interdependency Skill Library", + "longDescription": "Installs every skill in The Interdependency skill-lib and supplies a local, evidence-bearing usage counter from experimental through daily use.", + "shortDescription": "All skill-lib workflows with auditable maturity." + }, + "keywords": [ + "agent-skills", + "skill-library", + "provenance", + "maturity" + ], + "license": "MPL-2.0", + "name": "skill-lib", + "repository": "https://github.com/The-Interdependency/skill-lib", + "skills": "./skills/", + "version": "0.1.0" + } + }, + "origin": "native", + "source": { + "content_sha256": "642e69831ffab7f27ae41fbb4fd2b4a6c2a1df422133005886e0444d224d2eb4", + "file": ".codex-plugin/plugin.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.codex-plugin/plugin.json#subject/document/.codex-plugin%2Fplugin.json", + "identity": ".codex-plugin/plugin.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.github/FUNDING.yml#subject/document/.github%2FFUNDING.yml/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "yaml-core-string-keys", + "namespace": "yaml.document", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "3864ce4970e40f6083b8776a70a8d8727f01d629d9b5b5b76a3bfed11a9d57ca", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "yaml-core", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "custom": [ + "https://cash.app/$wayseer00" + ] + } + }, + "origin": "native", + "source": { + "content_sha256": "000c5a6e3351e7193988188de6137fccf51da02191eb0cfa60cf215e1264713c", + "file": ".github/FUNDING.yml", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.github/FUNDING.yml#subject/document/.github%2FFUNDING.yml", + "identity": ".github/FUNDING.yml", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.github/workflows/ci.yml#subject/document/.github%2Fworkflows%2Fci.yml/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "yaml-core-string-keys", + "namespace": "yaml.document", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "3864ce4970e40f6083b8776a70a8d8727f01d629d9b5b5b76a3bfed11a9d57ca", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "yaml-core", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "jobs": { + "checks": { + "runs-on": "ubuntu-latest", + "steps": [ + { + "uses": "actions/checkout@v7.0.1" + }, + { + "uses": "actions/setup-python@v7.0.0", + "with": { + "python-version": "3.13" + } + }, + { + "uses": "actions/setup-node@v6", + "with": { + "node-version": "24.15.0" + } + }, + { + "name": "Install pinned native-reader runtimes", + "run": "python -m pip install -r msdmd/requirements.txt\nnpm ci --ignore-scripts --prefix msdmd\n" + }, + { + "name": "Native collection drift and TypeScript schema", + "run": "python -m msdmd.collect --root . --repo The-Interdependency/skill-lib --snapshot-identity --import-path ./msdmd/collection --out skill-lib_msdmd.ts --strict --check\nnode msdmd/node_modules/typescript/bin/tsc --noEmit --strict --skipLibCheck --target ES2022 --module commonjs msdmd/collection.ts skill-lib_msdmd.ts\n" + }, + { + "name": "Unit tests", + "run": "python -m unittest discover -s tests" + }, + { + "name": "Gonol authority gate", + "run": "bash tools/check_gonol_authority.sh" + }, + { + "name": "Skill library drift", + "run": "python tools/check_skill_lib_drift.py --warnings-fail" + }, + { + "name": "Skill compliance", + "run": "python tools/check_skill_compliance.py --warnings-fail" + }, + { + "name": "Codex plugin adapter drift", + "run": "python tools/build_codex_plugin_skills.py --check" + }, + { + "name": "Ratios strict gate", + "run": "python ratios/ratios_check.py --strict" + }, + { + "name": "llms-build drift", + "run": "python -m llms.build --root . --out llms.txt --check" + }, + { + "name": "RepoLOTO audit", + "run": "python tests/test_repo_loto.py --audit" + }, + { + "name": "RepoLOTO checks", + "run": "python tests/test_repo_loto.py" + } + ] + } + }, + "name": "skill-lib-ci", + "on": { + "pull_request": null, + "push": { + "branches": [ + "main" + ] + } + }, + "permissions": { + "contents": "read" + } + } + }, + "origin": "native", + "source": { + "content_sha256": "5cee80a2a26176fe937224ff0365a826d180bd2784dcfb9a7fa4bfcbf8259bed", + "file": ".github/workflows/ci.yml", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.github/workflows/ci.yml#subject/document/.github%2Fworkflows%2Fci.yml", + "identity": ".github/workflows/ci.yml", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.github/workflows/consumer-drift.yml#subject/document/.github%2Fworkflows%2Fconsumer-drift.yml/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "yaml-core-string-keys", + "namespace": "yaml.document", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "3864ce4970e40f6083b8776a70a8d8727f01d629d9b5b5b76a3bfed11a9d57ca", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "yaml-core", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "jobs": { + "drift": { + "runs-on": "ubuntu-latest", + "steps": [ + { + "name": "Check out canonical skill-lib", + "uses": "actions/checkout@v7.0.1", + "with": { + "path": "skill-lib" + } + }, + { + "name": "Check out consumer ${{ matrix.consumer }}", + "uses": "actions/checkout@v7.0.1", + "with": { + "path": "consumer", + "repository": "The-Interdependency/${{ matrix.consumer }}" + } + }, + { + "name": "Set up Python", + "uses": "actions/setup-python@v7.0.0", + "with": { + "python-version": "3.11" + } + }, + { + "name": "Detect vendored-skill drift", + "run": "cd skill-lib\nSHA=\"$(git rev-parse HEAD)\"\necho \"### ${{ matrix.consumer }} vs skill-lib@${SHA:0:7}\" >> \"$GITHUB_STEP_SUMMARY\"\necho '```' >> \"$GITHUB_STEP_SUMMARY\"\nset +e\npython tools/check_consumer_drift.py ../consumer --sha \"$SHA\" --require-vendored | tee -a \"$GITHUB_STEP_SUMMARY\"\nstatus=${PIPESTATUS[0]} # checker's exit code, not tee's\nset -e\necho '```' >> \"$GITHUB_STEP_SUMMARY\"\nif [ \"$status\" -ne 0 ]; then\n echo \"Drift detected — re-propagate with: python tools/propagate_skills.py <path-to-${{ matrix.consumer }}> --apply\" >> \"$GITHUB_STEP_SUMMARY\"\nfi\nexit \"$status\"\n", + "shell": "bash" + } + ], + "strategy": { + "fail-fast": false, + "matrix": { + "consumer": [ + "interdependent-lib", + "ucns", + "edcm", + "zfae", + "eml_ucns", + "ai-tiw", + "a0-betatest", + "metapat", + "a0", + "aimmh", + "pcea", + "ptcna", + "pubskill-lib", + "epac", + "stack" + ] + } + } + } + }, + "name": "consumer skill drift", + "on": { + "schedule": [ + { + "cron": "0 4 * * 1" + } + ], + "workflow_dispatch": null + }, + "permissions": { + "contents": "read" + } + } + }, + "origin": "native", + "source": { + "content_sha256": "1949c58d8ee22ea28c112df95ec78d42903066f318c8fb8a1a436bf7b63c6d07", + "file": ".github/workflows/consumer-drift.yml", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.github/workflows/consumer-drift.yml#subject/document/.github%2Fworkflows%2Fconsumer-drift.yml", + "identity": ".github/workflows/consumer-drift.yml", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.github/workflows/hygiene.yml#subject/document/.github%2Fworkflows%2Fhygiene.yml/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "yaml-core-string-keys", + "namespace": "yaml.document", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "3864ce4970e40f6083b8776a70a8d8727f01d629d9b5b5b76a3bfed11a9d57ca", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "yaml-core", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "jobs": { + "no-tracked-bytecode": { + "runs-on": "ubuntu-latest", + "steps": [ + { + "uses": "actions/checkout@v7.0.1" + }, + { + "name": "Fail if Python bytecode is tracked", + "run": "hits=\"$(git ls-files '*.pyc' '*.pyo' '**/__pycache__/*')\"\nif [ -n \"$hits\" ]; then\n echo \"::error::tracked Python bytecode found — add it to .gitignore and 'git rm -r --cached' it:\"\n echo \"$hits\"\n exit 1\nfi\necho \"OK: no tracked bytecode.\"\n" + } + ] + } + }, + "name": "hygiene", + "on": { + "pull_request": null, + "push": { + "branches": [ + "main" + ] + } + }, + "permissions": { + "contents": "read" + } + } + }, + "origin": "native", + "source": { + "content_sha256": "bb6ec9588c41c82e2674be0ecd2933a41df7aedc5e160c2e222f19860b5d8491", + "file": ".github/workflows/hygiene.yml", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.github/workflows/hygiene.yml#subject/document/.github%2Fworkflows%2Fhygiene.yml", + "identity": ".github/workflows/hygiene.yml", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A1/fact/ignore-rule/lines%3A2-2/__pycache__%2F", + "convention": { + "dialect": "gitignore", + "namespace": "git.ignore", + "version": "gitignore current documented grammar" + }, + "extraction": { + "configuration_sha256": "30d4bfb164b0a38e8bf63c67b5d8e7f8178dbae9db6e1378d8d79c4e35a0c1d6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "gitignore-lines", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "ignore-rule", + "native": { + "id": "__pycache__/", + "value": { + "anchored": false, + "directory_only": true, + "negated": false, + "order": 1, + "pattern": "__pycache__/" + } + }, + "origin": "native", + "source": { + "content_sha256": "1c59c80391b92c7d74c90f5724911fa4e79c8490dca69560e8b064c55fe34456", + "file": ".gitignore", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A1", + "identity": "rule:1", + "scope": "path-rule" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A2/fact/ignore-rule/lines%3A3-3/%2A.py%5Bcod%5D", + "convention": { + "dialect": "gitignore", + "namespace": "git.ignore", + "version": "gitignore current documented grammar" + }, + "extraction": { + "configuration_sha256": "30d4bfb164b0a38e8bf63c67b5d8e7f8178dbae9db6e1378d8d79c4e35a0c1d6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "gitignore-lines", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "ignore-rule", + "native": { + "id": "*.py[cod]", + "value": { + "anchored": false, + "directory_only": false, + "negated": false, + "order": 2, + "pattern": "*.py[cod]" + } + }, + "origin": "native", + "source": { + "content_sha256": "1c59c80391b92c7d74c90f5724911fa4e79c8490dca69560e8b064c55fe34456", + "file": ".gitignore", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A2", + "identity": "rule:2", + "scope": "path-rule" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A3/fact/ignore-rule/lines%3A4-4/%2A%24py.class", + "convention": { + "dialect": "gitignore", + "namespace": "git.ignore", + "version": "gitignore current documented grammar" + }, + "extraction": { + "configuration_sha256": "30d4bfb164b0a38e8bf63c67b5d8e7f8178dbae9db6e1378d8d79c4e35a0c1d6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "gitignore-lines", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "ignore-rule", + "native": { + "id": "*$py.class", + "value": { + "anchored": false, + "directory_only": false, + "negated": false, + "order": 3, + "pattern": "*$py.class" + } + }, + "origin": "native", + "source": { + "content_sha256": "1c59c80391b92c7d74c90f5724911fa4e79c8490dca69560e8b064c55fe34456", + "file": ".gitignore", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A3", + "identity": "rule:3", + "scope": "path-rule" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A4/fact/ignore-rule/lines%3A7-7/.pytest_cache%2F", + "convention": { + "dialect": "gitignore", + "namespace": "git.ignore", + "version": "gitignore current documented grammar" + }, + "extraction": { + "configuration_sha256": "30d4bfb164b0a38e8bf63c67b5d8e7f8178dbae9db6e1378d8d79c4e35a0c1d6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "gitignore-lines", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "ignore-rule", + "native": { + "id": ".pytest_cache/", + "value": { + "anchored": false, + "directory_only": true, + "negated": false, + "order": 4, + "pattern": ".pytest_cache/" + } + }, + "origin": "native", + "source": { + "content_sha256": "1c59c80391b92c7d74c90f5724911fa4e79c8490dca69560e8b064c55fe34456", + "file": ".gitignore", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A4", + "identity": "rule:4", + "scope": "path-rule" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A5/fact/ignore-rule/lines%3A8-8/.ruff_cache%2F", + "convention": { + "dialect": "gitignore", + "namespace": "git.ignore", + "version": "gitignore current documented grammar" + }, + "extraction": { + "configuration_sha256": "30d4bfb164b0a38e8bf63c67b5d8e7f8178dbae9db6e1378d8d79c4e35a0c1d6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "gitignore-lines", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "ignore-rule", + "native": { + "id": ".ruff_cache/", + "value": { + "anchored": false, + "directory_only": true, + "negated": false, + "order": 5, + "pattern": ".ruff_cache/" + } + }, + "origin": "native", + "source": { + "content_sha256": "1c59c80391b92c7d74c90f5724911fa4e79c8490dca69560e8b064c55fe34456", + "file": ".gitignore", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A5", + "identity": "rule:5", + "scope": "path-rule" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A6/fact/ignore-rule/lines%3A9-9/.mypy_cache%2F", + "convention": { + "dialect": "gitignore", + "namespace": "git.ignore", + "version": "gitignore current documented grammar" + }, + "extraction": { + "configuration_sha256": "30d4bfb164b0a38e8bf63c67b5d8e7f8178dbae9db6e1378d8d79c4e35a0c1d6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "gitignore-lines", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "ignore-rule", + "native": { + "id": ".mypy_cache/", + "value": { + "anchored": false, + "directory_only": true, + "negated": false, + "order": 6, + "pattern": ".mypy_cache/" + } + }, + "origin": "native", + "source": { + "content_sha256": "1c59c80391b92c7d74c90f5724911fa4e79c8490dca69560e8b064c55fe34456", + "file": ".gitignore", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A6", + "identity": "rule:6", + "scope": "path-rule" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A7/fact/ignore-rule/lines%3A12-12/.skill-lib%2F", + "convention": { + "dialect": "gitignore", + "namespace": "git.ignore", + "version": "gitignore current documented grammar" + }, + "extraction": { + "configuration_sha256": "30d4bfb164b0a38e8bf63c67b5d8e7f8178dbae9db6e1378d8d79c4e35a0c1d6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "gitignore-lines", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "ignore-rule", + "native": { + "id": ".skill-lib/", + "value": { + "anchored": false, + "directory_only": true, + "negated": false, + "order": 7, + "pattern": ".skill-lib/" + } + }, + "origin": "native", + "source": { + "content_sha256": "1c59c80391b92c7d74c90f5724911fa4e79c8490dca69560e8b064c55fe34456", + "file": ".gitignore", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A7", + "identity": "rule:7", + "scope": "path-rule" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A8/fact/ignore-rule/lines%3A15-15/.env", + "convention": { + "dialect": "gitignore", + "namespace": "git.ignore", + "version": "gitignore current documented grammar" + }, + "extraction": { + "configuration_sha256": "30d4bfb164b0a38e8bf63c67b5d8e7f8178dbae9db6e1378d8d79c4e35a0c1d6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "gitignore-lines", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "ignore-rule", + "native": { + "id": ".env", + "value": { + "anchored": false, + "directory_only": false, + "negated": false, + "order": 8, + "pattern": ".env" + } + }, + "origin": "native", + "source": { + "content_sha256": "1c59c80391b92c7d74c90f5724911fa4e79c8490dca69560e8b064c55fe34456", + "file": ".gitignore", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A8", + "identity": "rule:8", + "scope": "path-rule" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A9/fact/ignore-rule/lines%3A18-18/msdmd%2Fnode_modules%2F", + "convention": { + "dialect": "gitignore", + "namespace": "git.ignore", + "version": "gitignore current documented grammar" + }, + "extraction": { + "configuration_sha256": "30d4bfb164b0a38e8bf63c67b5d8e7f8178dbae9db6e1378d8d79c4e35a0c1d6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "gitignore-lines", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "ignore-rule", + "native": { + "id": "msdmd/node_modules/", + "value": { + "anchored": false, + "directory_only": true, + "negated": false, + "order": 9, + "pattern": "msdmd/node_modules/" + } + }, + "origin": "native", + "source": { + "content_sha256": "1c59c80391b92c7d74c90f5724911fa4e79c8490dca69560e8b064c55fe34456", + "file": ".gitignore", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/.gitignore#subject/path-rule/rule%3A9", + "identity": "rule:9", + "scope": "path-rule" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/LICENSE#subject/document/LICENSE/fact/license-declaration/document/MPL-2.0", + "convention": { + "dialect": "license-text", + "namespace": "license.text", + "version": "detector v1" + }, + "extraction": { + "configuration_sha256": "0df88ba5528297545698e1918e76fae88a00e98aa58186fb3204604df96989b8", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "license-text", + "reader_version": "1.0.0", + "support": "partial" + }, + "kind": "license-declaration", + "native": { + "id": "MPL-2.0", + "value": { + "detection_method": "exact-known-header", + "expression": "MPL-2.0", + "legal_interpretation": "not-performed", + "text": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "3f3d9e0024b1921b067d6f7f88deb4a60cbe7a78e76c64e3f1d7fc3b779b9d04", + "file": "LICENSE", + "location": { + "pointer": "document" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/LICENSE#subject/document/LICENSE", + "identity": "LICENSE", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/LICENSES/Apache-2.0.txt#subject/document/LICENSES%2FApache-2.0.txt/fact/license-declaration/document", + "convention": { + "dialect": "license-text", + "namespace": "license.text", + "version": "detector v1" + }, + "extraction": { + "configuration_sha256": "0df88ba5528297545698e1918e76fae88a00e98aa58186fb3204604df96989b8", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "license-text", + "reader_version": "1.0.0", + "support": "partial" + }, + "kind": "license-declaration", + "native": { + "id": null, + "value": { + "detection_method": "unrecognized-text", + "expression": "hmmm", + "legal_interpretation": "not-performed", + "text": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30", + "file": "LICENSES/Apache-2.0.txt", + "location": { + "pointer": "document" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/LICENSES/Apache-2.0.txt#subject/document/LICENSES%2FApache-2.0.txt", + "identity": "LICENSES/Apache-2.0.txt", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/a0p-instancing/SKILL.md#subject/document/a0p-instancing%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Methodology for instancing agents in a0-betatest (the a0p research instrument), whose model diverges from canonical a0. Load this when adding or changing an AgentInstance / CharacterSheet CRUD path, a per-instance native ZFAE weight bank or its training/distillation loop, a ZFAE inference mode, a sentinel evaluation or pending-override gate, a per-agent safetensors checkpoint, or volatile sub-context memory — anywhere under a0-betatest `backend/`. Use it before writing code that creates, addresses, trains, runs, governs, or persists an a0p agent, so the code follows a0p's per-user CRUD + native-ZFAE + sentinel model instead of a0's spawn/fork/merge model. For canonical a0 and its mirror a0ucns, use `agent-instantiation` instead — a0p does NOT have `sub_agent_spawn`, a spawn executor, or `InstanceMerge`.", + "name": "a0p-instancing" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "afd54fed7065edf91a38c3b287dfc5bad763aec3d0b32b1d540a0ba67effd547", + "file": "a0p-instancing/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/a0p-instancing/SKILL.md#subject/document/a0p-instancing%2FSKILL.md", + "identity": "a0p-instancing/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/action-calibration/SKILL.md#subject/document/action-calibration%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Action sizing and escalation doctrine. Load this when choosing between the smallest decisive experiment and a maximal coherent program; when asked for the highest-leverage action, minimal versus maximal action, what to do next under time, attention, money, compute, or coordination constraints; when deciding whether to run a bounded falsifier before a full build; or when a task risks scope sprawl. Do not load for a trivial fixed-scope task, immediate emergency containment, or ordinary prioritization that has no evidence or escalation decision.", + "name": "action-calibration" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "558a364d0e1f06474bdd5ce92196145f6e21567366b2fef8c3ad5df6c191016b", + "file": "action-calibration/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/action-calibration/SKILL.md#subject/document/action-calibration%2FSKILL.md", + "identity": "action-calibration/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/action-calibration/examples/cases.json#subject/document/action-calibration%2Fexamples%2Fcases.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "json.document", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "cases": [ + { + "activate": true, + "expected_choice": "minimal", + "id": "p7_length_four", + "maximal": "Certify all crossings, Alexander ideals, all length-four invariants, and nilpotent quotients.", + "minimal": "Evaluate the unique algebraically split four-component sublink.", + "prompt": "Should we compute one length-four Milnor invariant or complete every whole-link invariant first?", + "reason": "One exact integer can redirect the complete program." + }, + { + "activate": true, + "expected_choice": "prerequisite_repair", + "id": "spectral_before_topology", + "prompt": "Build the zeta spectral operator before the ribbon topology is certified.", + "reason": "The operator would depend on an unclosed geometric and topological object." + }, + { + "activate": true, + "expected_choice": "maximal", + "id": "production_migration", + "prompt": "Choose a small test or full plan for an irreversible user-data migration.", + "reason": "Irreversibility and user-data risk require complete due diligence even if a canary is included." + }, + { + "activate": true, + "cross_load": [ + "interdependent-work-graph" + ], + "expected_choice": "minimal_with_cross_load", + "id": "cross_repo_schema", + "prompt": "Which part of a cross-repository schema migration should execute first?", + "reason": "Action size and authority graph are separate decisions." + }, + { + "activate": false, + "expected_choice": "immediate_containment", + "id": "security_incident", + "prompt": "A credential is actively leaking; should we first compare minimal and maximal investigations?", + "reason": "Contain harm first; calibrate investigation after." + }, + { + "activate": false, + "expected_choice": "fixed_scope", + "id": "fixed_typo", + "prompt": "Correct one misspelled heading in a fixed file.", + "reason": "No meaningful evidence or escalation decision exists." + }, + { + "activate": true, + "expected_choice": "minimal", + "id": "same_protocol_control", + "prompt": "A P7 result looks prime-specific. Should we interpret it now or run P5 under the same protocol?", + "reason": "A same-protocol control is the smallest action that can falsify prime specificity." + }, + { + "activate": true, + "expected_choice": "maximal", + "id": "shared_setup_economy", + "prompt": "Ten checks require the same expensive one-time environment and together close one release gate.", + "reason": "Fragmenting the checks repeats nearly all setup and coordination." + } + ], + "schema": "the-interdependency.action-calibration.cases", + "version": "1.0.0" + } + }, + "origin": "native", + "source": { + "content_sha256": "e1e6268e5b1b3187fb4d7d870d7e0a0e2c2f0615d1a035edbcdfff5a86910aa4", + "file": "action-calibration/examples/cases.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/action-calibration/examples/cases.json#subject/document/action-calibration%2Fexamples%2Fcases.json", + "identity": "action-calibration/examples/cases.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/agent-instantiation/SKILL.md#subject/document/agent-instantiation%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Methodology for instantiating, forking, running, merging, and retiring agents in the a0 platform and its near-identical mirror a0ucns. Load this when adding or changing a sub-agent spawn path, a PCNA instance fork/merge, an agent definition or naming scheme, spawn caps or approval gating, an agent run/log table, a heartbeat-driven agent task, or a checkpoint of agent state. Use it before writing any code that creates, addresses, schedules, or tears down an agent or sub-agent, so the new code follows the platform's existing lifecycle, fork/merge, identity, and gating contracts rather than inventing a parallel one. NOTE — a0-betatest (a0p) has diverged to a different per-user CRUD + native-ZFAE instancing model — this skill's spawn/fork/merge sequence does NOT apply there; see \"a0-betatest divergence\".", + "name": "agent-instantiation" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "faed73e0f4b63af03c4314477231bf07453e9739aa66cd454cfd6ac80537d206", + "file": "agent-instantiation/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/agent-instantiation/SKILL.md#subject/document/agent-instantiation%2FSKILL.md", + "identity": "agent-instantiation/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/canon/SKILL.md#subject/document/canon%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Canonical-source and doctrine maintenance for The Interdependency skill library. Use this when deciding whether a claim, pattern, ratio, workflow, or repo-local practice should become canon; when moving source-backed behavior into a SKILL.md; when reconciling canonical skill-lib with repo-local `.agents/skills/` copies; or when preserving unresolved doctrine as `hmmm` instead of guessing.", + "name": "canon" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "28db85eccfcb4c682c0bc55def4932df0832806564dc1f28887a0987a279d3fc", + "file": "canon/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/canon/SKILL.md#subject/document/canon%2FSKILL.md", + "identity": "canon/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/cap-build/SKILL.md#subject/document/cap-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first capability inventory built on msdmd. Consume signatures, exports, annotations and API schemas; supplemental CAPABILITIES blocks express otherwise unrecorded behavior and boundaries. Keep declared surfaces separate from verified behavior. Load this when declaring module capabilities, building capability registries for agents, or auditing exposed surfaces against declared capabilities.", + "name": "cap-build" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "25415e0c97ca20892f1af1cd7089f23d98b1310c430b4258e4a207a608b66c51", + "file": "cap-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/cap-build/SKILL.md#subject/document/cap-build%2FSKILL.md", + "identity": "cap-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/char-compress/SKILL.md#subject/document/char-compress%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Character-based context compression for agent handoff and skill writing, owned as a skill-lib procedure rather than current UCNS mathematics. Use this when compressing a long thread, document, repo audit, canon handoff, or agent working-memory state; when a context window is filling and operative facts must survive; when writing a SKILL.md that should be flesh-dense and bone-sparse; or when checking whether a compression deleted negation, order, quantifier, operator, named object, value, decision, or unresolved hmmm. Historical bone/flesh and text-stack terminology is local compression notation, not a UCNS theorem/status transfer, active language-construction authority, or edcmbone metric implementation.", + "name": "char-compress" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "4043e8c527eb887aa614be8d5e34c2589beef16e53770f5fc26f430e8c69524b", + "file": "char-compress/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/char-compress/SKILL.md#subject/document/char-compress%2FSKILL.md", + "identity": "char-compress/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/char-compress/fixtures.json#subject/document/char-compress%2Ffixtures.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "json.document", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "description": "Minimum preservation fixtures for char-compress. These are not proof fixtures; they are executable guardrails against flattening, polarity loss, status drift, and hmmm deletion.", + "fixtures": [ + { + "expect": { + "flesh": [ + "a0", + "supervisor" + ], + "frozen_bones": [ + "not" + ] + }, + "forbid_anywhere": [ + "central coordinator", + "manager" + ], + "id": "negation_preserved", + "text": "a0 is not a supervisor." + }, + { + "expect": { + "flesh": [ + "char-compress", + "context-compression", + "procedure" + ], + "frozen_bones": [ + "only" + ] + }, + "forbid_anywhere": [ + "among others" + ], + "id": "quantifier_preserved", + "text": "Only char-compress owns this context-compression procedure." + }, + { + "expect": { + "flesh": [ + "README.md", + "skills.json", + "ORG_DISTRIBUTION.md" + ], + "frozen_bones": [ + "first", + "then", + "last" + ] + }, + "id": "order_preserved", + "text": "First fetch README.md, then update skills.json, last verify ORG_DISTRIBUTION.md." + }, + { + "expect": { + "flesh": [ + "The-Interdependency/skill-lib", + ".agents/skills/char-compress/", + "2026-06-04" + ] + }, + "id": "value_preserved", + "text": "Copy The-Interdependency/skill-lib to .agents/skills/char-compress/ on 2026-06-04." + }, + { + "expect": { + "flesh": [ + "char-compress" + ], + "frozen_bones": [ + "EXPERIMENTAL", + "not", + "DEFENDED" + ] + }, + "forbid_anywhere": [ + "char-compress is DEFENDED" + ], + "id": "status_preserved", + "text": "char-compress is EXPERIMENTAL and not DEFENDED." + }, + { + "expect": { + "flesh": [ + "carrier", + "slot", + "map", + "material", + "publish" + ], + "frozen_bones": [ + "private", + "secret", + "not" + ] + }, + "forbid_anywhere": [ + "publishable", + "public" + ], + "id": "secret_preserved", + "text": "The carrier slot map is private secret material; do not publish it." + }, + { + "expect": { + "flesh": [ + "executable", + "codec", + "fixture", + "runner" + ], + "frozen_bones": [ + "no", + "until" + ], + "hmmm": [ + "hmmm" + ] + }, + "id": "hmmm_preserved", + "text": "hmmm: no executable codec exists until the fixture runner lands." + }, + { + "expect": { + "flesh": [ + "Theorem", + "N", + "char-compress", + "edcmbone", + "metric", + "status", + "claimed" + ], + "frozen_bones": [ + "not" + ] + }, + "forbid_anywhere": [ + "UCNS proves char-compress", + "Theorem N validates char-compress", + "char-compress implements UCNS-A", + "edcmbone metric status is claimed" + ], + "id": "no_ucns_transfer", + "text": "Theorem N does not validate char-compress; edcmbone metric status is not claimed." + } + ], + "version": 1 + } + }, + "origin": "native", + "source": { + "content_sha256": "20ac24f517ad4224a2e82dda48bba42a4d5ee9a0ab24f234fde1571a11a894bd", + "file": "char-compress/fixtures.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/char-compress/fixtures.json#subject/document/char-compress%2Ffixtures.json", + "identity": "char-compress/fixtures.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/SKILL.md#subject/document/data-visualization%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Create effective data visualizations with Python (matplotlib, seaborn, plotly). Use this when building charts, choosing the right chart type for a dataset, creating publication-quality figures, or applying design principles like accessibility and color theory.", + "name": "data-visualization" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "4ca0d131514954517f0d2ecc39964698fd3ecd06bfeec4e5f1cb163795453e8e", + "file": "data-visualization/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/SKILL.md#subject/document/data-visualization%2FSKILL.md", + "identity": "data-visualization/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/examples/information-design-manifest.json#subject/document/data-visualization%2Fexamples%2Finformation-design-manifest.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "json.document", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "hmmm": [ + "Image-level grayscale and CVD review must be performed on the rendered artifact." + ], + "manual_gates": { + "cvd": "hmmm", + "grayscale": "hmmm", + "semantic": "pass" + }, + "message": "The reader can distinguish structural families from evidence states without relying on color alone.", + "nontext_pairs": [ + { + "background": "#F7F9FC", + "foreground": "#0072B2" + } + ], + "semantic_dimensions": { + "authority": "border", + "component_family": "hue", + "evidence_state": "shape+label", + "flow": "line_direction" + }, + "states": [ + { + "color": "#009E73", + "name": "supported", + "redundancy": [ + "label", + "solid_circle" + ] + }, + { + "color": "#D55E00", + "name": "falsified", + "redundancy": [ + "label", + "octagon" + ] + }, + { + "color": "#CC79A7", + "name": "errored", + "redundancy": [ + "label", + "diamond" + ] + }, + { + "color": "#F0E442", + "name": "unavailable", + "redundancy": [ + "label", + "hollow_square" + ] + }, + { + "color": "#6B7280", + "name": "historical", + "redundancy": [ + "label", + "dashed_enclosure" + ] + }, + { + "color": "#0072B2", + "name": "current", + "redundancy": [ + "label", + "double_border" + ] + } + ], + "text_pairs": [ + { + "background": "#0B1020", + "foreground": "#FFFFFF", + "size": "normal" + }, + { + "background": "#F7F9FC", + "foreground": "#111827", + "size": "normal" + } + ] + } + }, + "origin": "native", + "source": { + "content_sha256": "c92106fe2317f42e3757201b6a93e4ab58675c5ee3c7c5f7b58aa36f759924a6", + "file": "data-visualization/examples/information-design-manifest.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/examples/information-design-manifest.json#subject/document/data-visualization%2Fexamples%2Finformation-design-manifest.json", + "identity": "data-visualization/examples/information-design-manifest.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "61:6" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A149-149/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "61:6" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 149, + "start_line": 149 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "7:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A149-149/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "7:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 149, + "start_line": 149 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "117:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A149-149/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "117:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 149, + "start_line": 149 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:data-visualization/information_design_audit.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=117:4 imports_exports=7:4 calls_definitions=61:6" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 71, + "column": 71, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "identity": "data-visualization/information_design_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:data-visualization/information_design_audit.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=117:4 imports_exports=7:4 calls_definitions=61:6" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 149, + "span": { + "end": { + "byte": 6661, + "column": 71, + "line": 149 + }, + "start": { + "byte": 6590, + "column": 0, + "line": 149 + } + }, + "start_line": 149 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "identity": "data-visualization/information_design_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:data-visualization/information_design_audit.py::<module>", + "description": "Checks declared WCAG contrast pairs and verifies that information-bearing states\ninclude at least one non-color redundancy. It does not simulate human vision.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Pure-stdlib information-design manifest audit.", + "text": "Pure-stdlib information-design manifest audit.\n\nChecks declared WCAG contrast pairs and verifies that information-bearing states\ninclude at least one non-color redundancy. It does not simulate human vision.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 6, + "span": { + "end": { + "byte": 285, + "column": 3, + "line": 6 + }, + "start": { + "byte": 72, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "identity": "data-visualization/information_design_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "identity": "data-visualization/information_design_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "identity": "data-visualization/information_design_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "identity": "data-visualization/information_design_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "identity": "data-visualization/information_design_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "identity": "data-visualization/information_design_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "identity": "data-visualization/information_design_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/module/data-visualization%2Finformation_design_audit.py", + "identity": "data-visualization/information_design_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/_audit_pairs/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_audit_pairs", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:data-visualization/information_design_audit.py::function:_audit_pairs", + "decorators": [], + "kind": "function", + "name": "_audit_pairs", + "parent_identity": null, + "qualified_name": "_audit_pairs", + "signature": "def _audit_pairs(pairs: list[dict[str, Any]], *, default_threshold: float, pair_type: str) -> list[dict[str, Any]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 64, + "span": { + "end": { + "byte": 2232, + "column": 19, + "line": 64 + }, + "start": { + "byte": 1209, + "column": 0, + "line": 43 + } + }, + "start_line": 43 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/_audit_pairs", + "identity": "_audit_pairs", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/_srgb_channel/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_srgb_channel", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:data-visualization/information_design_audit.py::function:_srgb_channel", + "decorators": [], + "kind": "function", + "name": "_srgb_channel", + "parent_identity": null, + "qualified_name": "_srgb_channel", + "signature": "def _srgb_channel(value: int) -> float" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 24, + "span": { + "end": { + "byte": 636, + "column": 45, + "line": 24 + }, + "start": { + "byte": 465, + "column": 0, + "line": 20 + } + }, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/_srgb_channel", + "identity": "_srgb_channel", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/audit_manifest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "audit_manifest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:data-visualization/information_design_audit.py::function:audit_manifest", + "decorators": [], + "kind": "function", + "name": "audit_manifest", + "parent_identity": null, + "qualified_name": "audit_manifest", + "signature": "def audit_manifest(manifest: dict[str, Any]) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 121, + "span": { + "end": { + "byte": 5499, + "column": 129, + "line": 121 + }, + "start": { + "byte": 2235, + "column": 0, + "line": 67 + } + }, + "start_line": 67 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/audit_manifest", + "identity": "audit_manifest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/contrast_ratio/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "contrast_ratio", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:data-visualization/information_design_audit.py::function:contrast_ratio", + "decorators": [], + "kind": "function", + "name": "contrast_ratio", + "parent_identity": null, + "qualified_name": "contrast_ratio", + "signature": "def contrast_ratio(foreground: str, background: str) -> float" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 40, + "span": { + "end": { + "byte": 1206, + "column": 41, + "line": 40 + }, + "start": { + "byte": 958, + "column": 0, + "line": 36 + } + }, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/contrast_ratio", + "identity": "contrast_ratio", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:data-visualization/information_design_audit.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: list[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 144, + "span": { + "end": { + "byte": 6531, + "column": 49, + "line": 144 + }, + "start": { + "byte": 5502, + "column": 0, + "line": 124 + } + }, + "start_line": 124 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/relative_luminance/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "relative_luminance", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:data-visualization/information_design_audit.py::function:relative_luminance", + "decorators": [], + "kind": "function", + "name": "relative_luminance", + "parent_identity": null, + "qualified_name": "relative_luminance", + "signature": "def relative_luminance(color: str) -> float" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff3c3d33c642ec42525a6afaec2e6708d6a11e8be6790857f33526afeb496923", + "file": "data-visualization/information_design_audit.py", + "location": { + "end_line": 33, + "span": { + "end": { + "byte": 955, + "column": 47, + "line": 33 + }, + "start": { + "byte": 639, + "column": 0, + "line": 27 + } + }, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/information_design_audit.py#subject/symbol/relative_luminance", + "identity": "relative_luminance", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/visual-grammar.json#subject/document/data-visualization%2Fvisual-grammar.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "json.document", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "channels": { + "border": "authority, selection, or scope boundary", + "hue": "one categorical family or one semantic dimension", + "lightness": "emphasis or ordered magnitude", + "line_direction": "processing, dependency, causal, or temporal flow", + "line_style": "current, provisional, historical, or unavailable", + "pattern": "color-independent redundancy", + "position": "structural layer or reading order", + "shape": "state class or category redundancy", + "text": "exact semantic meaning" + }, + "palette": { + "blue": { + "default_role": "stable structural or informational family", + "hex": "#0072B2" + }, + "bluish_green": { + "default_role": "supported or continuous family", + "hex": "#009E73" + }, + "bone": { + "default_role": "neutral continuity or historical material", + "hex": "#E7E1D5" + }, + "charcoal": { + "default_role": "primary ink or authoritative outline", + "hex": "#111827" + }, + "dark_background": { + "default_role": "dark neutral substrate", + "hex": "#0B1020" + }, + "light_background": { + "default_role": "light neutral substrate", + "hex": "#F7F9FC" + }, + "orange": { + "default_role": "candidate, transformation, routing, or active transition", + "hex": "#E69F00" + }, + "provenance_gray": { + "default_role": "historical or de-emphasized provenance", + "hex": "#6B7280" + }, + "reddish_purple": { + "default_role": "meta-level, recursive, semantic, or transformation family", + "hex": "#CC79A7" + }, + "sky_blue": { + "default_role": "secondary informational channel", + "hex": "#56B4E9" + }, + "vermillion": { + "default_role": "diagnostic tension, contradiction, interruption, or error boundary", + "hex": "#D55E00" + }, + "yellow": { + "default_role": "localized highlight or unresolved marker", + "hex": "#F0E442" + } + }, + "principles": [ + "color encodes structure rather than decoration", + "no critical state is conveyed by color alone", + "salience is relational and budgeted", + "exact meaning remains textual or otherwise explicit", + "hue does not carry two independent semantic dimensions in one local visual field", + "project branding may override hues but not contrast, redundancy, or semantic audit requirements" + ], + "publication_gates": [ + "grayscale", + "color_vision_deficiency", + "contrast", + "semantic" + ], + "purpose": "Evidence-grounded defaults for information-bearing color and visual signaling.", + "schema_version": 1, + "state_defaults": { + "current": { + "color": "#0072B2", + "redundancy": [ + "label", + "double_border" + ] + }, + "errored": { + "color": "#CC79A7", + "redundancy": [ + "label", + "diamond_or_zigzag" + ] + }, + "falsified": { + "color": "#D55E00", + "redundancy": [ + "label", + "octagon_or_cross" + ] + }, + "historical": { + "color": "#6B7280", + "redundancy": [ + "label", + "dashed_enclosure" + ] + }, + "supported": { + "color": "#009E73", + "redundancy": [ + "label", + "solid_circle_or_line" + ] + }, + "unavailable": { + "color": "#F0E442", + "redundancy": [ + "label", + "hollow_square_or_dotted_line" + ] + } + }, + "wcag": { + "essential_nontext_min_contrast": 3.0, + "large_text_min_contrast": 3.0, + "normal_text_min_contrast": 4.5 + } + } + }, + "origin": "native", + "source": { + "content_sha256": "62eecb020ce1099ea4e5b2a982f12b34f1f849e152b12e0b642c0429a31a139b", + "file": "data-visualization/visual-grammar.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/data-visualization/visual-grammar.json#subject/document/data-visualization%2Fvisual-grammar.json", + "identity": "data-visualization/visual-grammar.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/deps-build/SKILL.md#subject/document/deps-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first dependency topology built on msdmd. Consume imports, package manifests, lockfiles and build declarations at their owning scopes; supplemental DEPENDENCIES blocks express remaining architectural intent. Preserve edge kinds, conditions and resolution uncertainty. Load this when declaring dependencies, auditing architecture drift, checking graph cycles, or wiring dependency topology checks into CI.", + "name": "deps-build" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "4cc9480007527a023f45b02aedc4bbc3b55eed6e02ca8da6b5d9b33017f23306", + "file": "deps-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/deps-build/SKILL.md#subject/document/deps-build%2FSKILL.md", + "identity": "deps-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/distributed-publication/SKILL.md#subject/document/distributed-publication%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Provenance-bearing publication from distributed source owners. Load this when assembling, displaying, or maintaining one ordered textbook, report, standard, corpus, archive, knowledge surface, or public reading sequence whose authoritative units live in multiple repositories or independently owned files; when a publication consumer must retrieve exact commits, blobs, and content digests; when source order, source-local license or status, explicit fallback, correction routing, or public build identity must remain intact. Load interdependent-work-graph with it. Do not load for ordinary single-repository documentation, a link index that does not reproduce source content, or cross-repository code coordination with no publication artifact.", + "name": "distributed-publication" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "0c97c012eee6486f4ce5d2d21fc62023d048d294c721cc5081462b63e893b3d7", + "file": "distributed-publication/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/distributed-publication/SKILL.md#subject/document/distributed-publication%2FSKILL.md", + "identity": "distributed-publication/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/distributed-publication/examples/manifest.json#subject/document/distributed-publication%2Fexamples%2Fmanifest.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "json.document", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "boundaries": { + "authorship_transfer": false, + "canonical_status_transfer": false, + "certification_status_transfer": false, + "digest_is_authentication": false, + "empirical_status_transfer": false, + "hmmm": [ + "Example identities and source license are intentionally unresolved; a real publication manifest pins exact values and matching rules." + ], + "license_transfer": false, + "measurement_status_transfer": false, + "ownership_transfer": false, + "proof_status_transfer": false + }, + "consumer": { + "commit": "hmmm", + "fallback_policy": "fail-closed-production|explicit-retained-snapshot", + "renderer": "exact-markdown-static", + "repository": "The-Interdependency/The-Interdependency.github.io", + "route_prefix": "/chapters/" + }, + "order_is_load_bearing": true, + "publication_id": "interdependency-textbook-0-7", + "publication_sha256": "hmmm", + "schema": "the-interdependency.distributed-publication", + "sources": [ + { + "authority": "Chapter Zero content, license, and source-local status", + "blob": "hmmm", + "commit": "hmmm", + "content_sha256": "hmmm", + "correction_target": "The-Interdependency/metapat:CHAPTER_ZERO.md", + "expected_title": "Chapter Zero", + "fallback": false, + "license": "hmmm", + "license_status": "human-review-required", + "path": "CHAPTER_ZERO.md", + "position": 0, + "repository": "The-Interdependency/metapat", + "source_id": "chapter-zero", + "status": "root ontology and theory" + } + ], + "title": "The Interdependency — Chapters Zero Through Seven", + "version": "1.0.0" + } + }, + "origin": "native", + "source": { + "content_sha256": "b680e7de8a1d32b0a2d23cbb7d183c77b8bc5b7366a23f7a99739027516dc582", + "file": "distributed-publication/examples/manifest.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/distributed-publication/examples/manifest.json#subject/document/distributed-publication%2Fexamples%2Fmanifest.json", + "identity": "distributed-publication/examples/manifest.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/doc-build/SKILL.md#subject/document/doc-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first documentation coverage built on msdmd. Consume docstrings, documentation comments and source-linked documents; supplemental DOCS blocks express remaining obligations. A consuming runner verifies references and reports missing information separately from unsupported extraction. Load this when adding or auditing module documentation, tying code surfaces to docs, or wiring documentation coverage checks into CI.", + "name": "doc-build" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "a797829f727aa63ec009212eb3e9259e18322443458733c88da5fe2d8b1f4c7d", + "file": "doc-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/doc-build/SKILL.md#subject/document/doc-build%2FSKILL.md", + "identity": "doc-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/docs/icon.svg#subject/document/docs%2Ficon.svg/fact/document-metadata/%2Fsvg", + "convention": { + "dialect": "xml", + "namespace": "svg.document-metadata", + "version": "SVG document subset v1" + }, + "extraction": { + "configuration_sha256": "a636d6b73590150040db1ccaaf5ce1b545664bfe42d467b39cae2cc2903dd3f2", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "svg-metadata", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "document-metadata", + "native": { + "id": null, + "value": { + "attributes": { + "aria-label": "skill-lib icon", + "height": "512", + "role": "img", + "viewBox": "0 0 100 100", + "width": "512" + }, + "description": null, + "title": "skill-lib — modules that speak for themselves" + } + }, + "origin": "native", + "source": { + "content_sha256": "d917cfd0d541b858f43aa1b5bb429fe9c53f5ec35adef642a26c9eecbbf55acf", + "file": "docs/icon.svg", + "location": { + "pointer": "/svg" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/docs/icon.svg#subject/document/docs%2Ficon.svg", + "identity": "docs/icon.svg", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/docs/work-graphs/repository-plan-report.json#subject/document/docs%2Fwork-graphs%2Frepository-plan-report.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "json.document", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "active_frontier": [ + "land and validate the deterministic portfolio-plan projection as an extension of interdependent-work-graph", + "propagate the repo-report convention to participating repositories without copying their canon into skill-lib", + "keep generated plugin adapters and skill indexes synchronized with canonical root skills", + "expand evidence-bearing skill usage and maturity without treating invocation counts as correctness", + "preserve visible hmmm and gap reporting as skills and repositories evolve" + ], + "authority": { + "does_not_own": [ + "METAPAT semantic canon", + "UCNS mathematical representation or proof status", + "EDCM measurement validity or empirical results", + "a0 runtime, agent memory, privacy, deployment, or user-data authority", + "ZFAE conceptual theory or empirical hypothesis status" + ], + "non_transfer": [ + "skill conformance does not establish scientific, semantic, mathematical, measurement, or empirical validity", + "vendoring a skill does not transfer the producer repository's substantive authority into skill-lib", + "portfolio aggregation does not centralize repo canon", + "a machine-readable digest is identity evidence and not producer authentication", + "missing repo reports remain visible incompletion rather than guessed status" + ], + "owns": [ + "canonical reusable agent-skill doctrine and skill distribution conventions for The Interdependency", + "msdmd metadata conventions and the skill-lib machine-readable skill index", + "cross-repository coordination doctrine in interdependent-work-graph", + "build, evidence, boundary, publication, skill-compliance, and propagation helper contracts implemented or specified in this repository", + "the repository-plan-report contract and deterministic portfolio projection mechanism" + ] + }, + "blocked": [ + "executed CI validation is currently blocked because GitHub Actions jobs for this PR terminate with zero steps and empty logs" + ], + "contract": { + "blob_sha": "9b347b2dff7692054b571602f30ee6d00c2e7265", + "path": "interdependent-work-graph/repository-plan-report.schema.json", + "repository": "The-Interdependency/skill-lib", + "version": "1.0.0" + }, + "cross_repository_relations": [ + { + "authority_transfer": false, + "relation": "consumer of build, boundary, agent, and cross-repository skills; repo-owned runtime authority", + "repository": "The-Interdependency/a0" + }, + { + "authority_transfer": false, + "relation": "consumer of build/evidence and cross-repository doctrine; repo-owned measurement authority", + "repository": "The-Interdependency/edcm" + }, + { + "authority_transfer": false, + "relation": "consumer of build/evidence doctrine; repo-owned semantic authority", + "repository": "The-Interdependency/metapat" + }, + { + "authority_transfer": false, + "relation": "consumer of build/evidence and cross-repository doctrine; repo-owned mathematical authority", + "repository": "The-Interdependency/ucns" + }, + { + "authority_transfer": false, + "relation": "consumer of module-build and coordination doctrine; repo-owned conceptual authority", + "repository": "The-Interdependency/zfae" + } + ], + "delivered": [ + { + "boundary": "metadata completeness and conformance do not establish domain truth", + "status": "canonical skill doctrine with reference parsers and selected helper tools", + "surface": "msdmd and metadata-block skill family" + }, + { + "boundary": "generated adapters point to canonical skill doctrine rather than becoming second sources of truth", + "status": "implemented distribution surface", + "surface": "machine-readable skill registry and generated Codex adapters" + }, + { + "boundary": "repository boundaries remain authority and provenance boundaries", + "status": "canonical cross-repository coordination doctrine", + "surface": "interdependent-work-graph" + }, + { + "boundary": "propagation copies doctrine; it does not prove consuming-repo behavior", + "status": "pure-stdlib helpers and documented distribution convention", + "surface": "organization skill propagation and drift/compliance tooling" + }, + { + "boundary": "the reporting schema constrains representation of status but does not decide repo status or transfer repo authority", + "status": "implemented on the portfolio-plan branch and pinned by immutable schema blob identity", + "surface": "repository-plan-report v1 contract and deterministic portfolio projection" + } + ], + "hmmm": [ + "organization-wide automatic portfolio membership discovery is intentionally not selected", + "persistent live service or user interface for work graphs remains unselected", + "cryptographic producer or transport authentication remains separate from content identities", + "future stack-manifest schema revision for typed participants and explicit hashed edges", + "cross-repository merge orchestration remains repository-host dependent", + "execution environment for the first full coordinated aggregate fixture while GitHub Actions runners fail before job steps" + ], + "machine_entrypoints": { + "agent_entrypoint": "AGENTS.md", + "portfolio_aggregator": "interdependent-work-graph/portfolio_plan.py", + "portfolio_contract": "interdependent-work-graph/repository-plan-report.schema.json", + "portfolio_docs": "interdependent-work-graph/PORTFOLIO_PLAN.md", + "portfolio_output_schema": "interdependent-work-graph/portfolio-plan.schema.json", + "repo_report": "docs/work-graphs/repository-plan-report.json", + "skills_index": "skills.json", + "system_overview": "README.md", + "work_graph_skill": "interdependent-work-graph/SKILL.md" + }, + "next_actions": [ + { + "action": "execute the repository-plan-report tests and first coordinated aggregate fixture when a runner is available", + "dependency": "GitHub Actions or another execution environment must actually start jobs; current Actions runs fail before steps begin", + "owner": "The-Interdependency/skill-lib" + }, + { + "action": "merge the skill-lib contract before companion repo-report PRs once validation is available", + "dependency": "portfolio-plan control-plane review and executable gate evidence", + "owner": "The-Interdependency/skill-lib" + }, + { + "action": "add future repository reports only through explicit portfolio membership decisions rather than organization-wide auto-discovery", + "dependency": "maintainer-selected portfolio scope", + "owner": "The-Interdependency/skill-lib" + } + ], + "portfolio_role": { + "downstream_contract": "skill-lib validates and projects reports, preserves non-transfer boundaries, and emits deterministic identities that agents can consume without reconstructing repo state from memory.", + "reports_to": { + "relation": "control-plane self-report for the same portfolio projection contract", + "repository": "The-Interdependency/skill-lib", + "skill": "interdependent-work-graph" + }, + "summary": "Provide the shared procedural and machine-readable coordination layer that lets self-contained repositories report their exact roles, evidence boundaries, status, and unresolved work into one deterministic cross-repository plan without centralizing their canon.", + "upstream_contract": "Each repository owns the report claims it emits and pins the exact source commit being described." + }, + "repository": "The-Interdependency/skill-lib", + "schema": "the-interdependency.repository-plan-report", + "source": { + "branch": "agent/portfolio-plan-projection", + "commit": "b9fe10ca0326d3ff8ad191d0922278143420bc14", + "generated_at": "2026-08-07", + "note": "This report describes the exact portfolio-plan implementation commit immediately beneath this report refresh. The refresh commit is coordination metadata and does not acquire semantic, mathematical, measurement, runtime, or empirical authority from consuming repositories." + }, + "status": { + "current_claim": "skill-lib provides canonical skill doctrine, generated agent adapters, distribution tooling, and machine-readable indexes; the portfolio-plan branch adds a deterministic extension of interdependent-work-graph with a frozen repo-report contract, output schema, aggregator, documentation, and focused tests.", + "latest_main_milestone": { + "commit": "868de866b0248aff6d35759ad9fdcc363a0d1406", + "description": "added evidence-grounded information-design checks and integrated them into the existing visualization skill surface" + }, + "state": "active skill library and cross-repository coordination infrastructure" + }, + "version": "1.0.0" + } + }, + "origin": "native", + "source": { + "content_sha256": "807ce96412196e00f9b9b6de3628297740e7f6510498f8afe3940f1b29082171", + "file": "docs/work-graphs/repository-plan-report.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/docs/work-graphs/repository-plan-report.json#subject/document/docs%2Fwork-graphs%2Frepository-plan-report.json", + "identity": "docs/work-graphs/repository-plan-report.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/domain-claims/SKILL.md#subject/document/domain-claims%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Domain-first lexical and semantic governance for canonical terms. Load this when a word or phrase is being promoted into a theorem term, ontology primitive, schema field, encoding label, skill doctrine, cross-domain mapping, or other meaning-bearing control surface; when multiple domains use the same word differently; when an acronym, initialism, symbol, or compact handle is being mistaken for a fixed expansion or definition; or when conversational provenance is about to be attached to a definition. Do not load for ordinary prose, casual wording choices, or simple dictionary explanations that will not control canon or structure.", + "name": "domain-claims" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "51f690e0cdf2f272c9428dbc9f80ec97052cc24998b124451ed227c135bc0754", + "file": "domain-claims/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/domain-claims/SKILL.md#subject/document/domain-claims%2FSKILL.md", + "identity": "domain-claims/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/epac-selection-display/SKILL.md#subject/document/epac-selection-display%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Evidence-bound EPAC target selection and display for WebMCP handoffs and other human-facing surfaces. Load this when choosing an EPAC element, molecule, construction receipt, comparison result, or available visualization to present; when preparing a receipt-backed EPAC display packet; when exposing the EPAC workflow as a selectable WebMCP skill; or when a requested EPAC display would require missing or invented geometry so the request can be refused or downgraded to verified source-backed output. Do not load to select EPAC or a UCNS candidate as canon, or for unrelated WebMCP catalogue changes.", + "name": "epac-selection-display" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8624e7fd168ce88fae1f7f512fcbac706e75de987cad4ffb40e2c49f9b41439", + "file": "epac-selection-display/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/epac-selection-display/SKILL.md#subject/document/epac-selection-display%2FSKILL.md", + "identity": "epac-selection-display/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/epac-selection-display/STACK_SOURCE_FIXTURE.json#subject/document/epac-selection-display%2FSTACK_SOURCE_FIXTURE.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "json.document", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "boundaries": { + "authority_transfer": false, + "canon_status_transfer": false, + "empirical_status_transfer": false, + "measurement_status_transfer": false, + "proof_status_transfer": false + }, + "hmmm": [ + "EPAC has no independent authoritative source repository at this historical source state." + ], + "schema": "the-interdependency.epac-selection-display-source-fixture", + "source": { + "commit": "5b24db9a7fe40df4b2791e1137ade5de01c78942", + "git_blob_sha": "a1f1dd6a50252349797806b2dc59897f1fb3a991", + "path": "research/epac/README.md", + "repository": "The-Interdependency/stack" + }, + "standing": "provisional stack-local EPAC research scaffold", + "usage": "Verify that the historical source identity cited by epac-selection-display is anchored to an exact stack commit, path, and Git blob before relying on it as provenance. Resolve the current live EPAC source separately on every use.", + "version": "1.0.0" + } + }, + "origin": "native", + "source": { + "content_sha256": "8ef696d80e1c13f44039cae09965aa87927b3ed65e0c726eb0aa9f637f1af788", + "file": "epac-selection-display/STACK_SOURCE_FIXTURE.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/epac-selection-display/STACK_SOURCE_FIXTURE.json#subject/document/epac-selection-display%2FSTACK_SOURCE_FIXTURE.json", + "identity": "epac-selection-display/STACK_SOURCE_FIXTURE.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/explore-data/SKILL.md#subject/document/explore-data%2FSKILL.md/fact/frontmatter/lines%3A1-5", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "argument-hint": "<table or file>", + "description": "Profile and explore a dataset to understand its shape, quality, and patterns. Use this when encountering a new table or file, checking null rates and column distributions, spotting data quality issues like duplicates or suspicious values, or deciding which dimensions and metrics to analyze.", + "name": "explore-data" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "b641cbc5cecc613d5065ddd5531cc88659b1f37ff9e9f3632cafbeb6501334c8", + "file": "explore-data/SKILL.md", + "location": { + "end_line": 5, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/explore-data/SKILL.md#subject/document/explore-data%2FSKILL.md", + "identity": "explore-data/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/fresh-making/SKILL.md#subject/document/fresh-making%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Deterministic restoration of derived-artifact consistency after authoritative inputs change. Load this when deciding whether generated or derived outputs are current; when regenerating MSDMD collections, documentation, projections, package indexes, calibration artifacts, or other outputs from exact source identities; when computing the minimum affected rebuild closure; when designing retryable regeneration across unreliable executors; or when a system needs to make artifacts provably fresh rather than merely recently rebuilt. Do not load for ordinary one-shot builds whose inputs and outputs have no persistent freshness contract.", + "name": "fresh-making" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "e0866a17bf653185abc32e2f39bec4a8311a429b62ff2d4d536d112cc4d5a806", + "file": "fresh-making/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/fresh-making/SKILL.md#subject/document/fresh-making%2FSKILL.md", + "identity": "fresh-making/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/gonol-build/SKILL.md#subject/document/gonol-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Construction, closure, and replay discipline for active gonol-language research. Load this when building or reviewing language constructions made from UCNS gonol objects in The-Interdependency/stack, or when checking closure, atomic participation, provenance, replay, and unresolved geometry boundaries. UCNS owns gonol objects, constructors, and geometry; Stack owns active construction research; EDCM owns measurement/evaluation only. Closed gonols participate atomically at admissible consuming scales; no universal adjacent-scale ladder is required. Pronunciation is not required unless an explicitly declared construction makes it part of the build. Do not load for unrelated geometry, ordinary prose editing, or measurement over already-closed gonols.", + "name": "gonol-build" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "273b9adb9f50e2bc1d0dd6c7620bef2ee3539aa76b1fc8870482a21ef2abc81c", + "file": "gonol-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/gonol-build/SKILL.md#subject/document/gonol-build%2FSKILL.md", + "identity": "gonol-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/SKILL.md#subject/document/interdependent-work-graph%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Cross-repository coordination for The Interdependency. Load this when a task spans, consumes, compares, publishes to, or can change the contract between two or more repositories; when an agent is about to choose one repo as its workspace for a stack-level problem; when exact producer, evidence-source, skill, semantic, mathematical, or measurement identities must travel together; or when creating a shared stack manifest, multi-repo handoff, coordinated release, or cross-repo validation plan.", + "name": "interdependent-work-graph" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "77b4d6af8a3150b45c9d0bb254252f2e82dcf72864e6e2a363e7478ef7c5a01e", + "file": "interdependent-work-graph/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/SKILL.md#subject/document/interdependent-work-graph%2FSKILL.md", + "identity": "interdependent-work-graph/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio-plan.schema.json#subject/document/interdependent-work-graph%2Fportfolio-plan.schema.json/fact/reference/%2Fproperties%2Factive_frontier%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/repoItems" + } + }, + "origin": "native", + "source": { + "content_sha256": "5a40c0c7362e1a1fa77d8e8132084e3deac927d870ac57dc760c2c85d08c925a", + "file": "interdependent-work-graph/portfolio-plan.schema.json", + "location": { + "pointer": "/properties/active_frontier/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio-plan.schema.json#subject/document/interdependent-work-graph%2Fportfolio-plan.schema.json", + "identity": "interdependent-work-graph/portfolio-plan.schema.json", + "scope": "document" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio-plan.schema.json#subject/document/interdependent-work-graph%2Fportfolio-plan.schema.json/fact/reference/%2Fproperties%2Fblocked%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/repoItems" + } + }, + "origin": "native", + "source": { + "content_sha256": "5a40c0c7362e1a1fa77d8e8132084e3deac927d870ac57dc760c2c85d08c925a", + "file": "interdependent-work-graph/portfolio-plan.schema.json", + "location": { + "pointer": "/properties/blocked/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio-plan.schema.json#subject/document/interdependent-work-graph%2Fportfolio-plan.schema.json", + "identity": "interdependent-work-graph/portfolio-plan.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio-plan.schema.json#subject/document/interdependent-work-graph%2Fportfolio-plan.schema.json/fact/reference/%2Fproperties%2Fhmmm%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/repoItems" + } + }, + "origin": "native", + "source": { + "content_sha256": "5a40c0c7362e1a1fa77d8e8132084e3deac927d870ac57dc760c2c85d08c925a", + "file": "interdependent-work-graph/portfolio-plan.schema.json", + "location": { + "pointer": "/properties/hmmm/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio-plan.schema.json#subject/document/interdependent-work-graph%2Fportfolio-plan.schema.json", + "identity": "interdependent-work-graph/portfolio-plan.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio-plan.schema.json#subject/schema/interdependent-work-graph%2Fportfolio-plan.schema.json/fact/schema-description/lines%3A%3F-%3F/https%3A%2F%2Fgithub.com%2FThe-Interdependency%2Fskill-lib%2Finterdependent-work-graph%2Fportfolio-plan.schema.json", + "convention": { + "dialect": "json.schema", + "namespace": "json.schema", + "version": "https://json-schema.org/draft/2020-12/schema" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "schema-description", + "native": { + "id": "https://github.com/The-Interdependency/skill-lib/interdependent-work-graph/portfolio-plan.schema.json", + "value": { + "$defs": { + "repoItems": { + "items": { + "additionalProperties": false, + "properties": { + "item": { + "minLength": 1, + "type": "string" + }, + "repository": { + "pattern": "^[^/]+/[^/]+$", + "type": "string" + } + }, + "required": [ + "repository", + "item" + ], + "type": "object" + }, + "type": "array" + } + }, + "$id": "https://github.com/The-Interdependency/skill-lib/interdependent-work-graph/portfolio-plan.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "additionalProperties": false, + "properties": { + "active_frontier": { + "$ref": "#/$defs/repoItems" + }, + "blocked": { + "$ref": "#/$defs/repoItems" + }, + "contract": { + "additionalProperties": false, + "properties": { + "report_schema_blob_sha": { + "const": "9b347b2dff7692054b571602f30ee6d00c2e7265" + }, + "report_schema_path": { + "const": "interdependent-work-graph/repository-plan-report.schema.json" + }, + "report_schema_version": { + "const": "1.0.0" + }, + "repository": { + "const": "The-Interdependency/skill-lib" + } + }, + "required": [ + "repository", + "report_schema_path", + "report_schema_version", + "report_schema_blob_sha" + ], + "type": "object" + }, + "cross_repository_dependencies": { + "items": { + "properties": { + "authority_transfer": { + "const": false + }, + "from": { + "pattern": "^[^/]+/[^/]+$", + "type": "string" + }, + "relation": { + "minLength": 1, + "type": "string" + }, + "to": { + "pattern": "^[^/]+/[^/]+$", + "type": "string" + } + }, + "required": [ + "from", + "to", + "relation", + "authority_transfer" + ], + "type": "object" + }, + "type": "array" + }, + "generated_from": { + "items": { + "additionalProperties": false, + "properties": { + "report_sha256": { + "pattern": "^[0-9a-f]{64}$", + "type": "string" + }, + "repository": { + "pattern": "^[^/]+/[^/]+$", + "type": "string" + }, + "source_commit": { + "pattern": "^[0-9a-f]{40}$", + "type": "string" + } + }, + "required": [ + "repository", + "source_commit", + "report_sha256" + ], + "type": "object" + }, + "type": "array" + }, + "hmmm": { + "$ref": "#/$defs/repoItems" + }, + "next_actions": { + "items": { + "additionalProperties": false, + "properties": { + "action": { + "minLength": 1, + "type": "string" + }, + "dependency": { + "type": "string" + }, + "owner": { + "minLength": 1, + "type": "string" + }, + "repository": { + "pattern": "^[^/]+/[^/]+$", + "type": "string" + } + }, + "required": [ + "repository", + "action", + "owner", + "dependency" + ], + "type": "object" + }, + "type": "array" + }, + "portfolio_plan_sha256": { + "pattern": "^[0-9a-f]{64}$", + "type": "string" + }, + "repositories": { + "items": { + "additionalProperties": false, + "properties": { + "authority": { + "type": "object" + }, + "delivered": { + "type": "array" + }, + "machine_entrypoints": { + "type": "object" + }, + "portfolio_role": { + "type": "object" + }, + "repository": { + "pattern": "^[^/]+/[^/]+$", + "type": "string" + }, + "status": { + "type": "object" + } + }, + "required": [ + "repository", + "authority", + "portfolio_role", + "status", + "delivered", + "machine_entrypoints" + ], + "type": "object" + }, + "type": "array" + }, + "schema": { + "const": "the-interdependency.portfolio-plan" + }, + "version": { + "const": "1.0.0" + } + }, + "required": [ + "schema", + "version", + "contract", + "generated_from", + "repositories", + "cross_repository_dependencies", + "active_frontier", + "next_actions", + "blocked", + "hmmm", + "portfolio_plan_sha256" + ], + "title": "The Interdependency portfolio plan", + "type": "object" + } + }, + "origin": "native", + "source": { + "content_sha256": "5a40c0c7362e1a1fa77d8e8132084e3deac927d870ac57dc760c2c85d08c925a", + "file": "interdependent-work-graph/portfolio-plan.schema.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio-plan.schema.json#subject/schema/interdependent-work-graph%2Fportfolio-plan.schema.json", + "identity": "interdependent-work-graph/portfolio-plan.schema.json", + "scope": "schema" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A230-230/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 230, + "start_line": 230 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A230-230/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 230, + "start_line": 230 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A230-230/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 230, + "start_line": 230 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 71, + "column": 71, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "identity": "interdependent-work-graph/portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: interdependent_work_graph_portfolio_plan\n module_name: portfolio_plan\n module_kind: instrument\n summary: validates repo-owned plan reports and derives a deterministic cross-repository portfolio projection without transferring authority\n owner: The-Interdependency/skill-lib maintainers\n public_surface: load_report, build_portfolio, main\n internal_surface: validate_report, canonical_bytes, digest\n auth_boundary: none\n storage_boundary: none\n network_boundary: none\n user_data_boundary: none\n admin_only: false\n tests: tests/test_interdependent_work_graph_portfolio_plan.py\n rollout: explicit CLI or library invocation after repo reports are supplied\n rollback: remove the aggregator, schemas, companion docs, and portfolio projection section without changing repo-owned source claims\n unresolved: automatic portfolio membership discovery, persistent live service, cryptographic producer authentication\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 36, + "span": { + "end": { + "byte": 1834, + "column": 26, + "line": 36 + }, + "start": { + "byte": 830, + "column": 0, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "identity": "interdependent-work-graph/portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 230, + "span": { + "end": { + "byte": 12141, + "column": 71, + "line": 230 + }, + "start": { + "byte": 12070, + "column": 0, + "line": 230 + } + }, + "start_line": 230 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "identity": "interdependent-work-graph/portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::<module>", + "description": "No network access and no third-party packages are required. Repository reports\nremain authoritative for their own claims; this program only validates,\norders, hashes, and projects them into a cross-repository view.\n\nUsage guidance:\n python interdependent-work-graph/portfolio_plan.py ../a0/docs/work-graphs/repository-plan-report.json ../edcm/docs/work-graphs/repository-plan-report.json --output portfolio-plan.json\n\nSupply only the repositories intentionally included in the portfolio view.\nMissing repositories are not auto-discovered or synthesized. A report must pin\nthe exact frozen report-schema blob and the source commit it describes.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Validate repo-owned plan reports and derive one deterministic portfolio plan.", + "text": "Validate repo-owned plan reports and derive one deterministic portfolio plan.\n\nNo network access and no third-party packages are required. Repository reports\nremain authoritative for their own claims; this program only validates,\norders, hashes, and projects them into a cross-repository view.\n\nUsage guidance:\n python interdependent-work-graph/portfolio_plan.py ../a0/docs/work-graphs/repository-plan-report.json ../edcm/docs/work-graphs/repository-plan-report.json --output portfolio-plan.json\n\nSupply only the repositories intentionally included in the portfolio view.\nMissing repositories are not auto-discovered or synthesized. A report must pin\nthe exact frozen report-schema blob and the source commit it describes.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 17, + "span": { + "end": { + "byte": 828, + "column": 3, + "line": 17 + }, + "start": { + "byte": 72, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "identity": "interdependent-work-graph/portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 38, + "start_line": 38 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "identity": "interdependent-work-graph/portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 40, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "identity": "interdependent-work-graph/portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 41, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "identity": "interdependent-work-graph/portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 42, + "start_line": 42 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "identity": "interdependent-work-graph/portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 43, + "start_line": 43 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "identity": "interdependent-work-graph/portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 44, + "start_line": 44 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "identity": "interdependent-work-graph/portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 45, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/module/interdependent-work-graph%2Fportfolio_plan.py", + "identity": "interdependent-work-graph/portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/_require/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_require", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::function:_require", + "decorators": [], + "kind": "function", + "name": "_require", + "parent_identity": null, + "qualified_name": "_require", + "signature": "def _require(condition: bool, message: str) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 67, + "span": { + "end": { + "byte": 2725, + "column": 33, + "line": 67 + }, + "start": { + "byte": 2617, + "column": 0, + "line": 65 + } + }, + "start_line": 65 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/_require", + "identity": "_require", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/_string_list/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_string_list", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::function:_string_list", + "decorators": [], + "kind": "function", + "name": "_string_list", + "parent_identity": null, + "qualified_name": "_string_list", + "signature": "def _string_list(value: Any, field: str) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 73, + "span": { + "end": { + "byte": 2977, + "column": 16, + "line": 73 + }, + "start": { + "byte": 2728, + "column": 0, + "line": 70 + } + }, + "start_line": 70 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/_string_list", + "identity": "_string_list", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/build_portfolio/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "build_portfolio", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::function:build_portfolio", + "decorators": [], + "kind": "function", + "name": "build_portfolio", + "parent_identity": null, + "qualified_name": "build_portfolio", + "signature": "def build_portfolio(reports_with_paths: list[tuple[Path, dict[str, Any]]]) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 208, + "span": { + "end": { + "byte": 11299, + "column": 58, + "line": 208 + }, + "start": { + "byte": 8655, + "column": 0, + "line": 155 + } + }, + "start_line": 155 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/build_portfolio", + "identity": "build_portfolio", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/canonical_bytes/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "canonical_bytes", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::function:canonical_bytes", + "decorators": [], + "kind": "function", + "name": "canonical_bytes", + "parent_identity": null, + "qualified_name": "canonical_bytes", + "signature": "def canonical_bytes(value: Any) -> bytes" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 58, + "span": { + "end": { + "byte": 2519, + "column": 103, + "line": 58 + }, + "start": { + "byte": 2374, + "column": 0, + "line": 57 + } + }, + "start_line": 57 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/canonical_bytes", + "identity": "canonical_bytes", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/digest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "digest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::function:digest", + "decorators": [], + "kind": "function", + "name": "digest", + "parent_identity": null, + "qualified_name": "digest", + "signature": "def digest(value: Any) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 62, + "span": { + "end": { + "byte": 2614, + "column": 61, + "line": 62 + }, + "start": { + "byte": 2522, + "column": 0, + "line": 61 + } + }, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/digest", + "identity": "digest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/load_report/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "load_report", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::function:load_report", + "decorators": [], + "kind": "function", + "name": "load_report", + "parent_identity": null, + "qualified_name": "load_report", + "signature": "def load_report(path: Path) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 152, + "span": { + "end": { + "byte": 8652, + "column": 16, + "line": 152 + }, + "start": { + "byte": 8419, + "column": 0, + "line": 148 + } + }, + "start_line": 148 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/load_report", + "identity": "load_report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main() -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 225, + "span": { + "end": { + "byte": 12011, + "column": 12, + "line": 225 + }, + "start": { + "byte": 11302, + "column": 0, + "line": 211 + } + }, + "start_line": 211 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/validate_report/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "validate_report", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:interdependent-work-graph/portfolio_plan.py::function:validate_report", + "decorators": [], + "kind": "function", + "name": "validate_report", + "parent_identity": null, + "qualified_name": "validate_report", + "signature": "def validate_report(report: dict[str, Any], source_path: Path) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "97cc5064065f81199f4145a8c3a5d653fcf35109df3cec4ffbbaab61c86bb3ab", + "file": "interdependent-work-graph/portfolio_plan.py", + "location": { + "end_line": 145, + "span": { + "end": { + "byte": 8416, + "column": 185, + "line": 145 + }, + "start": { + "byte": 2980, + "column": 0, + "line": 76 + } + }, + "start_line": 76 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/portfolio_plan.py#subject/symbol/validate_report", + "identity": "validate_report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/repository-plan-report.schema.json#subject/schema/interdependent-work-graph%2Frepository-plan-report.schema.json/fact/schema-description/lines%3A%3F-%3F/https%3A%2F%2Fgithub.com%2FThe-Interdependency%2Fskill-lib%2Finterdependent-work-graph%2Frepository-plan-report.schema.json", + "convention": { + "dialect": "json.schema", + "namespace": "json.schema", + "version": "https://json-schema.org/draft/2020-12/schema" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "schema-description", + "native": { + "id": "https://github.com/The-Interdependency/skill-lib/interdependent-work-graph/repository-plan-report.schema.json", + "value": { + "$id": "https://github.com/The-Interdependency/skill-lib/interdependent-work-graph/repository-plan-report.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "additionalProperties": false, + "properties": { + "active_frontier": { + "items": { + "minLength": 1, + "type": "string" + }, + "type": "array" + }, + "authority": { + "additionalProperties": false, + "properties": { + "does_not_own": { + "items": { + "minLength": 1, + "type": "string" + }, + "type": "array" + }, + "non_transfer": { + "items": { + "minLength": 1, + "type": "string" + }, + "minItems": 1, + "type": "array" + }, + "owns": { + "items": { + "minLength": 1, + "type": "string" + }, + "minItems": 1, + "type": "array" + } + }, + "required": [ + "owns", + "does_not_own", + "non_transfer" + ], + "type": "object" + }, + "blocked": { + "items": { + "minLength": 1, + "type": "string" + }, + "type": "array" + }, + "contract": { + "additionalProperties": false, + "properties": { + "blob_sha": { + "pattern": "^[0-9a-f]{40}$", + "type": "string" + }, + "path": { + "const": "interdependent-work-graph/repository-plan-report.schema.json" + }, + "repository": { + "const": "The-Interdependency/skill-lib" + }, + "version": { + "const": "1.0.0" + } + }, + "required": [ + "repository", + "path", + "version", + "blob_sha" + ], + "type": "object" + }, + "cross_repository_relations": { + "items": { + "additionalProperties": true, + "properties": { + "authority_transfer": { + "const": false + }, + "relation": { + "minLength": 1, + "type": "string" + }, + "repository": { + "pattern": "^[^/]+/[^/]+$", + "type": "string" + } + }, + "required": [ + "repository", + "relation", + "authority_transfer" + ], + "type": "object" + }, + "type": "array" + }, + "delivered": { + "items": { + "additionalProperties": false, + "properties": { + "boundary": { + "minLength": 1, + "type": "string" + }, + "status": { + "minLength": 1, + "type": "string" + }, + "surface": { + "minLength": 1, + "type": "string" + } + }, + "required": [ + "surface", + "status", + "boundary" + ], + "type": "object" + }, + "type": "array" + }, + "hmmm": { + "items": { + "minLength": 1, + "type": "string" + }, + "type": "array" + }, + "machine_entrypoints": { + "additionalProperties": { + "minLength": 1, + "type": "string" + }, + "minProperties": 1, + "type": "object" + }, + "next_actions": { + "items": { + "additionalProperties": false, + "properties": { + "action": { + "minLength": 1, + "type": "string" + }, + "dependency": { + "type": "string" + }, + "owner": { + "minLength": 1, + "type": "string" + } + }, + "required": [ + "action", + "owner", + "dependency" + ], + "type": "object" + }, + "type": "array" + }, + "portfolio_role": { + "additionalProperties": false, + "properties": { + "downstream_contract": { + "type": "string" + }, + "reports_to": { + "additionalProperties": false, + "properties": { + "relation": { + "minLength": 1, + "type": "string" + }, + "repository": { + "const": "The-Interdependency/skill-lib" + }, + "skill": { + "const": "interdependent-work-graph" + } + }, + "required": [ + "repository", + "skill", + "relation" + ], + "type": "object" + }, + "summary": { + "minLength": 1, + "type": "string" + }, + "upstream_contract": { + "type": "string" + } + }, + "required": [ + "summary", + "reports_to" + ], + "type": "object" + }, + "repository": { + "pattern": "^[^/]+/[^/]+$", + "type": "string" + }, + "schema": { + "const": "the-interdependency.repository-plan-report" + }, + "source": { + "additionalProperties": false, + "properties": { + "branch": { + "minLength": 1, + "type": "string" + }, + "commit": { + "pattern": "^[0-9a-f]{40}$", + "type": "string" + }, + "generated_at": { + "format": "date", + "type": "string" + }, + "note": { + "minLength": 1, + "type": "string" + } + }, + "required": [ + "branch", + "commit", + "generated_at", + "note" + ], + "type": "object" + }, + "status": { + "additionalProperties": true, + "properties": { + "current_claim": { + "minLength": 1, + "type": "string" + }, + "state": { + "minLength": 1, + "type": "string" + } + }, + "required": [ + "state", + "current_claim" + ], + "type": "object" + }, + "version": { + "const": "1.0.0" + } + }, + "required": [ + "schema", + "version", + "repository", + "contract", + "source", + "authority", + "portfolio_role", + "status", + "delivered", + "active_frontier", + "next_actions", + "blocked", + "cross_repository_relations", + "machine_entrypoints", + "hmmm" + ], + "title": "The Interdependency repository plan report", + "type": "object" + } + }, + "origin": "native", + "source": { + "content_sha256": "f04f1583be8725511113e2bb3280bf28459ad39824687bf8bcd0761c1bd14e80", + "file": "interdependent-work-graph/repository-plan-report.schema.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/interdependent-work-graph/repository-plan-report.schema.json#subject/schema/interdependent-work-graph%2Frepository-plan-report.schema.json", + "identity": "interdependent-work-graph/repository-plan-report.schema.json", + "scope": "schema" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms-build/SKILL.md#subject/document/llms-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first LLM instruction publication built on msdmd. Consume source-owned instruction metadata without requiring a second copy; the shipped stdlib runner generates llms.txt from LLMS blocks, while native-reader integration remains a contract. Load this when creating, updating, or maintaining llms.txt for repositories consumed by LLMs or agents.", + "name": "llms-build" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "df9a67ed1efbec408247883142e4bbddf11d93afa39ef1d8cdb2a65fb28a2403", + "file": "llms-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms-build/SKILL.md#subject/document/llms-build%2FSKILL.md", + "identity": "llms-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/document-section/heading%3A1/fact/instruction-section/lines%3A1-1/LLM%20Instructions%20for%20skill-lib", + "convention": { + "dialect": "llms.txt", + "namespace": "llms.txt", + "version": "Markdown structural subset v1" + }, + "extraction": { + "configuration_sha256": "37940da2a5e228d0a2e15c16138283285d282dcccbb250827bc326cbd8cef0d5", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "llms-text", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "instruction-section", + "native": { + "id": "LLM Instructions for skill-lib", + "value": { + "generated": "hmmm", + "level": 1, + "title": "LLM Instructions for skill-lib" + } + }, + "origin": "native", + "source": { + "content_sha256": "d4ca5833418e3af7617957fe3a0d6f28b21a260dfb85c73e9e72736b0c4231fe", + "file": "llms.txt", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/document-section/heading%3A1", + "identity": "heading:1", + "scope": "document-section" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/document-section/heading%3A12/fact/instruction-section/lines%3A12-12/Architecture%20Summary", + "convention": { + "dialect": "llms.txt", + "namespace": "llms.txt", + "version": "Markdown structural subset v1" + }, + "extraction": { + "configuration_sha256": "37940da2a5e228d0a2e15c16138283285d282dcccbb250827bc326cbd8cef0d5", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "llms-text", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "instruction-section", + "native": { + "id": "Architecture Summary", + "value": { + "generated": "hmmm", + "level": 2, + "title": "Architecture Summary" + } + }, + "origin": "native", + "source": { + "content_sha256": "d4ca5833418e3af7617957fe3a0d6f28b21a260dfb85c73e9e72736b0c4231fe", + "file": "llms.txt", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/document-section/heading%3A12", + "identity": "heading:12", + "scope": "document-section" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/document-section/heading%3A18/fact/instruction-section/lines%3A18-18/How%20to%20Use%20This%20Repo%20with%20LLMs%20%2F%20Agents", + "convention": { + "dialect": "llms.txt", + "namespace": "llms.txt", + "version": "Markdown structural subset v1" + }, + "extraction": { + "configuration_sha256": "37940da2a5e228d0a2e15c16138283285d282dcccbb250827bc326cbd8cef0d5", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "llms-text", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "instruction-section", + "native": { + "id": "How to Use This Repo with LLMs / Agents", + "value": { + "generated": "hmmm", + "level": 2, + "title": "How to Use This Repo with LLMs / Agents" + } + }, + "origin": "native", + "source": { + "content_sha256": "d4ca5833418e3af7617957fe3a0d6f28b21a260dfb85c73e9e72736b0c4231fe", + "file": "llms.txt", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/document-section/heading%3A18", + "identity": "heading:18", + "scope": "document-section" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/document-section/heading%3A3/fact/instruction-section/lines%3A3-3/Project%20Overview", + "convention": { + "dialect": "llms.txt", + "namespace": "llms.txt", + "version": "Markdown structural subset v1" + }, + "extraction": { + "configuration_sha256": "37940da2a5e228d0a2e15c16138283285d282dcccbb250827bc326cbd8cef0d5", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "llms-text", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "instruction-section", + "native": { + "id": "Project Overview", + "value": { + "generated": "hmmm", + "level": 2, + "title": "Project Overview" + } + }, + "origin": "native", + "source": { + "content_sha256": "d4ca5833418e3af7617957fe3a0d6f28b21a260dfb85c73e9e72736b0c4231fe", + "file": "llms.txt", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/document-section/heading%3A3", + "identity": "heading:3", + "scope": "document-section" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/document-section/heading%3A7/fact/instruction-section/lines%3A7-7/Key%20Definitions%20%28never%20infer%20or%20expand%20these%29", + "convention": { + "dialect": "llms.txt", + "namespace": "llms.txt", + "version": "Markdown structural subset v1" + }, + "extraction": { + "configuration_sha256": "37940da2a5e228d0a2e15c16138283285d282dcccbb250827bc326cbd8cef0d5", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "llms-text", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "instruction-section", + "native": { + "id": "Key Definitions (never infer or expand these)", + "value": { + "generated": "hmmm", + "level": 2, + "title": "Key Definitions (never infer or expand these)" + } + }, + "origin": "native", + "source": { + "content_sha256": "d4ca5833418e3af7617957fe3a0d6f28b21a260dfb85c73e9e72736b0c4231fe", + "file": "llms.txt", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/document-section/heading%3A7", + "identity": "heading:7", + "scope": "document-section" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/instruction-definition/char-compress/fact/key-definition/lines%3A9-9/char-compress", + "convention": { + "dialect": "llms.txt", + "namespace": "llms.txt", + "version": "Markdown structural subset v1" + }, + "extraction": { + "configuration_sha256": "37940da2a5e228d0a2e15c16138283285d282dcccbb250827bc326cbd8cef0d5", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "llms-text", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "key-definition", + "native": { + "id": "char-compress", + "value": { + "definition": "Skill-lib-owned character-based context compression for agent handoff and skill writing; its historical bone/flesh and text-stack notation is not current UCNS mathematics.", + "generated": "hmmm", + "term": "char-compress" + } + }, + "origin": "native", + "source": { + "content_sha256": "d4ca5833418e3af7617957fe3a0d6f28b21a260dfb85c73e9e72736b0c4231fe", + "file": "llms.txt", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/instruction-definition/char-compress", + "identity": "char-compress", + "scope": "instruction-definition" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/instruction-definition/llms-build/fact/key-definition/lines%3A10-10/llms-build", + "convention": { + "dialect": "llms.txt", + "namespace": "llms.txt", + "version": "Markdown structural subset v1" + }, + "extraction": { + "configuration_sha256": "37940da2a5e228d0a2e15c16138283285d282dcccbb250827bc326cbd8cef0d5", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "llms-text", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "key-definition", + "native": { + "id": "llms-build", + "value": { + "definition": "LLM instruction publication from owning metadata; the shipped runner generates root llms.txt from LLMS blocks, while native-reader integration remains a contract.", + "generated": "hmmm", + "term": "llms-build" + } + }, + "origin": "native", + "source": { + "content_sha256": "d4ca5833418e3af7617957fe3a0d6f28b21a260dfb85c73e9e72736b0c4231fe", + "file": "llms.txt", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/instruction-definition/llms-build", + "identity": "llms-build", + "scope": "instruction-definition" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/instruction-definition/msdmd/fact/key-definition/lines%3A8-8/msdmd", + "convention": { + "dialect": "llms.txt", + "namespace": "llms.txt", + "version": "Markdown structural subset v1" + }, + "extraction": { + "configuration_sha256": "37940da2a5e228d0a2e15c16138283285d282dcccbb250827bc326cbd8cef0d5", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "llms-text", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "key-definition", + "native": { + "id": "msdmd", + "value": { + "definition": "Module Self-Declared Metadata in Markdown — native-first collection of existing code, documentation, manifest, schema, tooling and evidence metadata; MSDMD blocks supply otherwise unexpressed information. The schema-2 collector integrates native source and document readers with qualified provenance, structured docstrings, shared Python comment attachment and required-fact policies; unsupported scope remains explicit.", + "generated": "hmmm", + "term": "msdmd" + } + }, + "origin": "native", + "source": { + "content_sha256": "d4ca5833418e3af7617957fe3a0d6f28b21a260dfb85c73e9e72736b0c4231fe", + "file": "llms.txt", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms.txt#subject/instruction-definition/msdmd", + "identity": "msdmd", + "scope": "instruction-definition" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "d280c6b1fd17e76cc97a1f77e25993f37ea9e1387199a1f713e30fbc32deef5b", + "file": "llms/__init__.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A3-3/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "d280c6b1fd17e76cc97a1f77e25993f37ea9e1387199a1f713e30fbc32deef5b", + "file": "llms/__init__.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "d280c6b1fd17e76cc97a1f77e25993f37ea9e1387199a1f713e30fbc32deef5b", + "file": "llms/__init__.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A3-3/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "d280c6b1fd17e76cc97a1f77e25993f37ea9e1387199a1f713e30fbc32deef5b", + "file": "llms/__init__.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "0:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "d280c6b1fd17e76cc97a1f77e25993f37ea9e1387199a1f713e30fbc32deef5b", + "file": "llms/__init__.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A3-3/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "0:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "d280c6b1fd17e76cc97a1f77e25993f37ea9e1387199a1f713e30fbc32deef5b", + "file": "llms/__init__.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/module/llms%2F__init__.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:llms/__init__.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=0:1 imports_exports=0:0 calls_definitions=0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "d280c6b1fd17e76cc97a1f77e25993f37ea9e1387199a1f713e30fbc32deef5b", + "file": "llms/__init__.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 68, + "column": 68, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/module/llms%2F__init__.py", + "identity": "llms/__init__.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/module/llms%2F__init__.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:llms/__init__.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=0:1 imports_exports=0:0 calls_definitions=0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "d280c6b1fd17e76cc97a1f77e25993f37ea9e1387199a1f713e30fbc32deef5b", + "file": "llms/__init__.py", + "location": { + "end_line": 3, + "span": { + "end": { + "byte": 208, + "column": 68, + "line": 3 + }, + "start": { + "byte": 140, + "column": 0, + "line": 3 + } + }, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/module/llms%2F__init__.py", + "identity": "llms/__init__.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/module/llms%2F__init__.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:llms/__init__.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "llms-build reference package for generating root llms.txt files.", + "text": "llms-build reference package for generating root llms.txt files." + } + }, + "origin": "native", + "source": { + "content_sha256": "d280c6b1fd17e76cc97a1f77e25993f37ea9e1387199a1f713e30fbc32deef5b", + "file": "llms/__init__.py", + "location": { + "end_line": 2, + "span": { + "end": { + "byte": 139, + "column": 70, + "line": 2 + }, + "start": { + "byte": 69, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/__init__.py#subject/module/llms%2F__init__.py", + "identity": "llms/__init__.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "66:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A283-283/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "66:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 283, + "start_line": 283 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "6:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A283-283/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "6:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 283, + "start_line": 283 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "229:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A283-283/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "229:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 283, + "start_line": 283 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=229:5 imports_exports=6:7 calls_definitions=66:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 72, + "column": 72, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "identity": "llms/build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=229:5 imports_exports=6:7 calls_definitions=66:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 283, + "span": { + "end": { + "byte": 8264, + "column": 72, + "line": 283 + }, + "start": { + "byte": 8192, + "column": 0, + "line": 283 + } + }, + "start_line": 283 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "identity": "llms/build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "identity": "llms/build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "identity": "llms/build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "identity": "llms/build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "dataclasses:dataclass:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "dataclasses", + "name": "dataclass" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "identity": "llms/build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "identity": "llms/build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterable:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "identity": "llms/build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Sequence:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Sequence" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/module/llms%2Fbuild.py", + "identity": "llms/build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/Entry/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "Entry", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::class:Entry", + "decorators": [ + "dataclass" + ], + "kind": "class", + "name": "Entry", + "parent_identity": null, + "qualified_name": "Entry", + "signature": "class Entry" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 61, + "span": { + "end": { + "byte": 1007, + "column": 26, + "line": 61 + }, + "start": { + "byte": 930, + "column": 0, + "line": 57 + } + }, + "start_line": 57 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/Entry", + "identity": "Entry", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/_content_for/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_content_for", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:_content_for", + "decorators": [], + "kind": "function", + "name": "_content_for", + "parent_identity": null, + "qualified_name": "_content_for", + "signature": "def _content_for(entries: list[Entry], entry_id: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 202, + "span": { + "end": { + "byte": 5294, + "column": 50, + "line": 202 + }, + "start": { + "byte": 5009, + "column": 0, + "line": 196 + } + }, + "start_line": 196 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/_content_for", + "identity": "_content_for", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/_definition_lines/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_definition_lines", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:_definition_lines", + "decorators": [], + "kind": "function", + "name": "_definition_lines", + "parent_identity": null, + "qualified_name": "_definition_lines", + "signature": "def _definition_lines(entries: list[Entry]) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 214, + "span": { + "end": { + "byte": 5686, + "column": 41, + "line": 214 + }, + "start": { + "byte": 5297, + "column": 0, + "line": 205 + } + }, + "start_line": 205 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/_definition_lines", + "identity": "_definition_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/_markdown_without_fenced_code/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_markdown_without_fenced_code", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:_markdown_without_fenced_code", + "decorators": [], + "kind": "function", + "name": "_markdown_without_fenced_code", + "parent_identity": null, + "qualified_name": "_markdown_without_fenced_code", + "signature": "def _markdown_without_fenced_code(text: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 82, + "span": { + "end": { + "byte": 1616, + "column": 25, + "line": 82 + }, + "start": { + "byte": 1099, + "column": 0, + "line": 68 + } + }, + "start_line": 68 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/_markdown_without_fenced_code", + "identity": "_markdown_without_fenced_code", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/_markdown_without_fenced_code/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:_markdown_without_fenced_code", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Replace fenced-code bodies with blank lines so examples are not parsed.", + "text": "Replace fenced-code bodies with blank lines so examples are not parsed." + } + }, + "origin": "native", + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 69, + "span": { + "end": { + "byte": 1233, + "column": 81, + "line": 69 + }, + "start": { + "byte": 1156, + "column": 4, + "line": 69 + } + }, + "start_line": 69 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/_markdown_without_fenced_code", + "identity": "_markdown_without_fenced_code", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/collect/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "collect", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:collect", + "decorators": [], + "kind": "function", + "name": "collect", + "parent_identity": null, + "qualified_name": "collect", + "signature": "def collect(root: Path) -> list[Entry]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 193, + "span": { + "end": { + "byte": 5006, + "column": 18, + "line": 193 + }, + "start": { + "byte": 4590, + "column": 0, + "line": 182 + } + }, + "start_line": 182 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/collect", + "identity": "collect", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/generate/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "generate", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:generate", + "decorators": [], + "kind": "function", + "name": "generate", + "parent_identity": null, + "qualified_name": "generate", + "signature": "def generate(entries: list[Entry], repo_name: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 242, + "span": { + "end": { + "byte": 6734, + "column": 5, + "line": 242 + }, + "start": { + "byte": 5689, + "column": 0, + "line": 217 + } + }, + "start_line": 217 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/generate", + "identity": "generate", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/iter_files.walk/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "iter_files.walk", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:iter_files.walk", + "decorators": [], + "kind": "function", + "name": "walk", + "parent_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:iter_files", + "qualified_name": "iter_files.walk", + "signature": "def walk(path: Path) -> Iterable[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 177, + "span": { + "end": { + "byte": 4560, + "column": 27, + "line": 177 + }, + "start": { + "byte": 4097, + "column": 4, + "line": 164 + } + }, + "start_line": 164 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/iter_files.walk", + "identity": "iter_files.walk", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/iter_files/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "iter_files", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:iter_files", + "decorators": [], + "kind": "function", + "name": "iter_files", + "parent_identity": null, + "qualified_name": "iter_files", + "signature": "def iter_files(root: Path, skip: Iterable[str] | None=None) -> Iterable[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 179, + "span": { + "end": { + "byte": 4587, + "column": 25, + "line": 179 + }, + "start": { + "byte": 3942, + "column": 0, + "line": 161 + } + }, + "start_line": 161 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/iter_files", + "identity": "iter_files", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: Sequence[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 278, + "span": { + "end": { + "byte": 8133, + "column": 12, + "line": 278 + }, + "start": { + "byte": 6737, + "column": 0, + "line": 245 + } + }, + "start_line": 245 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/marker_for/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "marker_for", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:marker_for", + "decorators": [], + "kind": "function", + "name": "marker_for", + "parent_identity": null, + "qualified_name": "marker_for", + "signature": "def marker_for(path: Path) -> str | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 65, + "span": { + "end": { + "byte": 1096, + "column": 44, + "line": 65 + }, + "start": { + "byte": 1010, + "column": 0, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/marker_for", + "identity": "marker_for", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/parse_text.emit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_text.emit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:parse_text.emit", + "decorators": [], + "kind": "function", + "name": "emit", + "parent_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:parse_text", + "qualified_name": "parse_text.emit", + "signature": "def emit() -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 107, + "span": { + "end": { + "byte": 2524, + "column": 28, + "line": 107 + }, + "start": { + "byte": 2247, + "column": 4, + "line": 101 + } + }, + "start_line": 101 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/parse_text.emit", + "identity": "parse_text.emit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/parse_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:parse_text", + "decorators": [], + "kind": "function", + "name": "parse_text", + "parent_identity": null, + "qualified_name": "parse_text", + "signature": "def parse_text(text: str, marker: str='#', *, source: Path | None=None) -> list[Entry]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 158, + "span": { + "end": { + "byte": 3939, + "column": 18, + "line": 158 + }, + "start": { + "byte": 1619, + "column": 0, + "line": 85 + } + }, + "start_line": 85 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/parse_text", + "identity": "parse_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/parse_text/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:llms/build.py::function:parse_text", + "description": "This is intentionally small and stdlib-only. It follows msdmd shape while\nallowing key-definition field names such as ``char-compress``.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Parse LLMS entries from one file.", + "text": "Parse LLMS entries from one file.\n\n This is intentionally small and stdlib-only. It follows msdmd shape while\n allowing key-definition field names such as ``char-compress``.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "2c4a20547ddd0661b8b8199d869af7fed0e995d9690bafea7790c1aef4c43888", + "file": "llms/build.py", + "location": { + "end_line": 90, + "span": { + "end": { + "byte": 1905, + "column": 7, + "line": 90 + }, + "start": { + "byte": 1715, + "column": 4, + "line": 86 + } + }, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/build.py#subject/symbol/parse_text", + "identity": "parse_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A27-27/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "end_line": 27, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A27-27/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "end_line": 27, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "0:24" + } + }, + "origin": "native", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A27-27/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "0:24" + } + }, + "origin": "native", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "end_line": 27, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/module/llms%2Fmetadata.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:llms/metadata.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=0:24 imports_exports=0:0 calls_definitions=0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 69, + "column": 69, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/module/llms%2Fmetadata.py", + "identity": "llms/metadata.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/module/llms%2Fmetadata.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:llms/metadata.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== LLMS ===\nid: project_overview\n content: skill-lib is the canonical organization-wide source for reusable agent skills in The Interdependency.\n It provides msdmd-based metadata skills, procedural skills, pure-stdlib helper tools, and propagation guidance for consuming repositories.\n\nid: key_definitions\n msdmd: Module Self-Declared Metadata in Markdown — native-first collection of existing code, documentation, manifest, schema, tooling and evidence metadata; MSDMD blocks supply otherwise unexpressed information. The schema-2 collector integrates native source and document readers with qualified provenance, structured docstrings, shared Python comment attachment and required-fact policies; unsupported scope remains explicit.\n char-compress: Skill-lib-owned character-based context compression for agent handoff and skill writing; its historical bone/flesh and text-stack notation is not current UCNS mathematics.\n llms-build: LLM instruction publication from owning metadata; the shipped runner generates root llms.txt from LLMS blocks, while native-reader integration remains a contract.\n\nid: architecture_summary\n content: - Skills live as root directories with SKILL.md files and optional helpers.\n - Metadata skills consume native owning conventions first; supplemental blocks include DOCS, CAPABILITIES, DEPENDENCIES, OWNERS, CONTRACTS, CHECKS, MODULE_BUILD, BOUNDARIES and LLMS. RATIOS keeps its separate non-block boundary syntax.\n - Procedural skills define agent behavior without adding a metadata block.\n - Pure-stdlib helpers live under tools; the llms package provides the python -m llms.build runner.\n\nid: usage_rules\n content: - Read AGENTS.md, skills.json, and the relevant skill file before changing a skill.\n - Ground responses in literal repository files including skill specs, parser source, helper source, README.md, ORG_DISTRIBUTION.md, CLAUDE.md, and generated llms.txt.\n - Do not infer or expand declared key definitions.\n - Write unresolved or missing values as hmmm; unsupported readers and unvalidated identities do not establish complete coverage.\n - Edit source LLMS blocks before regenerating llms.txt.\n=== END LLMS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "end_line": 26, + "span": { + "end": { + "byte": 2354, + "column": 18, + "line": 26 + }, + "start": { + "byte": 120, + "column": 0, + "line": 4 + } + }, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/module/llms%2Fmetadata.py", + "identity": "llms/metadata.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/module/llms%2Fmetadata.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:llms/metadata.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=0:24 imports_exports=0:0 calls_definitions=0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "end_line": 27, + "span": { + "end": { + "byte": 2424, + "column": 69, + "line": 27 + }, + "start": { + "byte": 2355, + "column": 0, + "line": 27 + } + }, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/module/llms%2Fmetadata.py", + "identity": "llms/metadata.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/module/llms%2Fmetadata.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:llms/metadata.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Self-declared LLMS metadata for skill-lib.", + "text": "Self-declared LLMS metadata for skill-lib." + } + }, + "origin": "native", + "source": { + "content_sha256": "39f74bff5b40067cf19fd08f45d6e75f58e8e38354bdb77cf27a70fa78a796c7", + "file": "llms/metadata.py", + "location": { + "end_line": 2, + "span": { + "end": { + "byte": 118, + "column": 48, + "line": 2 + }, + "start": { + "byte": 70, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/llms/metadata.py#subject/module/llms%2Fmetadata.py", + "identity": "llms/metadata.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/loop-eng/SKILL.md#subject/document/loop-eng%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Loop engineering for designing closed feedback cycles (Discover→Plan→Execute→Verify→Iterate), single-agent and fleet loops with subagent maker/checker separation, and automated verify-iterate workflows. Load this when building or orchestrating agent systems (a0p, AIMMH), EDCMBONE analysis pipelines, repeatable AI workflows, or any The-Interdependency project that benefits from structured loops instead of manual prompting. Cross-load with the-interdependency for org workflow context.", + "name": "loop-eng" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "11d0eaa099e3d12d59240eee6675ec9d1d6ac81b8d28d29689870afef26d5ce6", + "file": "loop-eng/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/loop-eng/SKILL.md#subject/document/loop-eng%2FSKILL.md", + "identity": "loop-eng/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/SKILL.md#subject/document/manifest%2FSKILL.md/fact/frontmatter/lines%3A1-16", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Living-spec generator. Derives the mechanical, observable facts of a repo (package name, version, description, license, authors, repository, build backend, development status, supported Python versions, keywords, runtime dependencies, optional extras, top-level layout, CI workflows) from pyproject.toml + the file tree and splices them into a machine-owned, marked block inside CLAUDE.md — keeping the doc from silently drifting from the code. Ships a stdlib-only generator with --write (refresh), --check (CI drift gate), and --print modes. Load this when: setting up or maintaining a CLAUDE.md / AGENTS.md so its factual half is generated rather than hand-typed; wiring a CI check that fails when docs drift from pyproject/version/deps/layout; deciding which parts of a doc to generate vs. hand-author; or onboarding a new org repo to the living-spec convention.", + "name": "manifest" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "453a183e33fe4c3d8e7dc000cb649da9ac5baec3f29205db9e373c20abd9a9b6", + "file": "manifest/SKILL.md", + "location": { + "end_line": 16, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/SKILL.md#subject/document/manifest%2FSKILL.md", + "identity": "manifest/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "81:16" + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A303-303/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "81:16" + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 303, + "start_line": 303 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "6:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A303-303/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "6:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 303, + "start_line": 303 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "209:37" + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A303-303/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "209:37" + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 303, + "start_line": 303 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=209:37 imports_exports=6:5 calls_definitions=81:16" + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 73, + "column": 73, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::<module>", + "metadata_kind": "comment", + "text": "Python < 3.11" + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 45, + "span": { + "end": { + "byte": 2045, + "column": 44, + "line": 45 + }, + "start": { + "byte": 2030, + "column": 29, + "line": 45 + } + }, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::<module>", + "metadata_kind": "comment", + "text": "never guess an unknown fact; surface it as a visible gap" + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 50, + "span": { + "end": { + "byte": 2223, + "column": 73, + "line": 50 + }, + "start": { + "byte": 2165, + "column": 15, + "line": 50 + } + }, + "start_line": 50 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::<module>", + "metadata_kind": "comment", + "text": "Directories that are noise rather than structure." + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 52, + "span": { + "end": { + "byte": 2276, + "column": 51, + "line": 52 + }, + "start": { + "byte": 2225, + "column": 0, + "line": 52 + } + }, + "start_line": 52 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=209:37 imports_exports=6:5 calls_definitions=81:16" + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 303, + "span": { + "end": { + "byte": 11359, + "column": 73, + "line": 303 + }, + "start": { + "byte": 11286, + "column": 0, + "line": 303 + } + }, + "start_line": 303 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::<module>", + "description": "Living-spec tool (msdmd family). It derives *observable* facts about a repo —\npackage metadata (name, version, description, license, authors, repository,\nbuild backend, development status, supported Python versions, keywords, runtime\ndependencies, optional extras), plus tree facts (top-level layout, CI\nworkflows) — directly from `pyproject.toml` and the file tree, and splices them\ninto a marked, machine-owned block in CLAUDE.md:\n\n <!-- BEGIN GENERATED:manifest -->\n ...derived facts...\n <!-- END GENERATED:manifest -->\n\nEverything *outside* that block stays hand-authored (the judgement: why a\nboundary exists, scope, claim status, gotchas). The block is treated like a\nlockfile: never hand-edited, regenerated by tooling, and a CI `--check` fails\nthe build when it drifts from the code.\n\nIt only derives facts it can read with confidence; anything genuinely absent\nrenders as `hmmm` (a visible gap to fix at the source), never a guess. Fuzzy\ninference (e.g. the exact test command) is intentionally left to hand-authored\nprose rather than risk emitting a wrong \"fact\". If the pyproject itself is\nmissing or unparseable, the tool fails loudly rather than emit an all-`hmmm`\nblock.\n\nStdlib only (msdmd ethos). Requires Python 3.11+ to run because it uses\n`tomllib`; it is a dev/CI tool and is never shipped inside any package.\n\nUsage (exactly one mode is required):\n python generate.py --print # show the block, no writes\n python generate.py --write # splice/refresh the block\n python generate.py --check # exit 1 if the block is stale\n python generate.py --root . --file CLAUDE.md --pyproject backend/pyproject.toml --write", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "manifest — generate the mechanical half of a repo's CLAUDE.md from source.", + "text": "manifest — generate the mechanical half of a repo's CLAUDE.md from source.\n\nLiving-spec tool (msdmd family). It derives *observable* facts about a repo —\npackage metadata (name, version, description, license, authors, repository,\nbuild backend, development status, supported Python versions, keywords, runtime\ndependencies, optional extras), plus tree facts (top-level layout, CI\nworkflows) — directly from `pyproject.toml` and the file tree, and splices them\ninto a marked, machine-owned block in CLAUDE.md:\n\n <!-- BEGIN GENERATED:manifest -->\n ...derived facts...\n <!-- END GENERATED:manifest -->\n\nEverything *outside* that block stays hand-authored (the judgement: why a\nboundary exists, scope, claim status, gotchas). The block is treated like a\nlockfile: never hand-edited, regenerated by tooling, and a CI `--check` fails\nthe build when it drifts from the code.\n\nIt only derives facts it can read with confidence; anything genuinely absent\nrenders as `hmmm` (a visible gap to fix at the source), never a guess. Fuzzy\ninference (e.g. the exact test command) is intentionally left to hand-authored\nprose rather than risk emitting a wrong \"fact\". If the pyproject itself is\nmissing or unparseable, the tool fails loudly rather than emit an all-`hmmm`\nblock.\n\nStdlib only (msdmd ethos). Requires Python 3.11+ to run because it uses\n`tomllib`; it is a dev/CI tool and is never shipped inside any package.\n\nUsage (exactly one mode is required):\n python generate.py --print # show the block, no writes\n python generate.py --write # splice/refresh the block\n python generate.py --check # exit 1 if the block is stale\n python generate.py --root . --file CLAUDE.md --pyproject backend/pyproject.toml --write\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 35, + "span": { + "end": { + "byte": 1877, + "column": 3, + "line": 35 + }, + "start": { + "byte": 74, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 36, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 38, + "start_line": 38 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 39, + "start_line": 39 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 40, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 41, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tomllib:tomllib:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tomllib", + "name": "tomllib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 44, + "start_line": 44 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/module/manifest%2Fgenerate.py", + "identity": "manifest/generate.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/ManifestError/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "ManifestError", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::class:ManifestError", + "decorators": [], + "kind": "class", + "name": "ManifestError", + "parent_identity": null, + "qualified_name": "ManifestError", + "signature": "class ManifestError(Exception)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 61, + "span": { + "end": { + "byte": 2583, + "column": 82, + "line": 61 + }, + "start": { + "byte": 2469, + "column": 0, + "line": 60 + } + }, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/ManifestError", + "identity": "ManifestError", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/ManifestError/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::class:ManifestError", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Raised for unrecoverable conditions (unreadable source, broken markers).", + "text": "Raised for unrecoverable conditions (unreadable source, broken markers)." + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 61, + "span": { + "end": { + "byte": 2583, + "column": 82, + "line": 61 + }, + "start": { + "byte": 2505, + "column": 4, + "line": 61 + } + }, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/ManifestError", + "identity": "ManifestError", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_authors/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_authors", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_authors", + "decorators": [], + "kind": "function", + "name": "_authors", + "parent_identity": null, + "qualified_name": "_authors", + "signature": "def _authors(proj: dict) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 116, + "span": { + "end": { + "byte": 4333, + "column": 14, + "line": 116 + }, + "start": { + "byte": 4006, + "column": 0, + "line": 106 + } + }, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_authors", + "identity": "_authors", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_cell/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_cell", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_cell", + "decorators": [], + "kind": "function", + "name": "_cell", + "parent_identity": null, + "qualified_name": "_cell", + "signature": "def _cell(value: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 174, + "span": { + "end": { + "byte": 6300, + "column": 68, + "line": 174 + }, + "start": { + "byte": 6138, + "column": 0, + "line": 172 + } + }, + "start_line": 172 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_cell", + "identity": "_cell", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_cell/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_cell", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Make a value safe for a one-line markdown table cell.", + "text": "Make a value safe for a one-line markdown table cell." + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 173, + "span": { + "end": { + "byte": 6231, + "column": 63, + "line": 173 + }, + "start": { + "byte": 6172, + "column": 4, + "line": 173 + } + }, + "start_line": 173 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_cell", + "identity": "_cell", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_ci_workflows/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_ci_workflows", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_ci_workflows", + "decorators": [], + "kind": "function", + "name": "_ci_workflows", + "parent_identity": null, + "qualified_name": "_ci_workflows", + "signature": "def _ci_workflows(root: Path) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 103, + "span": { + "end": { + "byte": 4003, + "column": 80, + "line": 103 + }, + "start": { + "byte": 3797, + "column": 0, + "line": 99 + } + }, + "start_line": 99 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_ci_workflows", + "identity": "_ci_workflows", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_dev_status/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_dev_status", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_dev_status", + "decorators": [], + "kind": "function", + "name": "_dev_status", + "parent_identity": null, + "qualified_name": "_dev_status", + "signature": "def _dev_status(classifiers: list[str]) -> str | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 131, + "span": { + "end": { + "byte": 4757, + "column": 15, + "line": 131 + }, + "start": { + "byte": 4551, + "column": 0, + "line": 127 + } + }, + "start_line": 127 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_dev_status", + "identity": "_dev_status", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_joined/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_joined", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_joined", + "decorators": [], + "kind": "function", + "name": "_joined", + "parent_identity": null, + "qualified_name": "_joined", + "signature": "def _joined(items: list[str], code: bool=False, empty: str='none') -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 184, + "span": { + "end": { + "byte": 6593, + "column": 100, + "line": 184 + }, + "start": { + "byte": 6375, + "column": 0, + "line": 181 + } + }, + "start_line": 181 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_joined", + "identity": "_joined", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_load_pyproject/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_load_pyproject", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_load_pyproject", + "decorators": [], + "kind": "function", + "name": "_load_pyproject", + "parent_identity": null, + "qualified_name": "_load_pyproject", + "signature": "def _load_pyproject(path: Path) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 85, + "span": { + "end": { + "byte": 3495, + "column": 70, + "line": 85 + }, + "start": { + "byte": 3078, + "column": 0, + "line": 77 + } + }, + "start_line": 77 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_load_pyproject", + "identity": "_load_pyproject", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_load_pyproject/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_load_pyproject", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Parse pyproject; raise ManifestError if missing or invalid (never silent).", + "text": "Parse pyproject; raise ManifestError if missing or invalid (never silent)." + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 78, + "span": { + "end": { + "byte": 3203, + "column": 84, + "line": 78 + }, + "start": { + "byte": 3123, + "column": 4, + "line": 78 + } + }, + "start_line": 78 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_load_pyproject", + "identity": "_load_pyproject", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_py_versions/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_py_versions", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_py_versions", + "decorators": [], + "kind": "function", + "name": "_py_versions", + "parent_identity": null, + "qualified_name": "_py_versions", + "signature": "def _py_versions(classifiers: list[str]) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 140, + "span": { + "end": { + "byte": 4991, + "column": 14, + "line": 140 + }, + "start": { + "byte": 4760, + "column": 0, + "line": 134 + } + }, + "start_line": 134 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_py_versions", + "identity": "_py_versions", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_refresh_cmd/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_refresh_cmd", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_refresh_cmd", + "decorators": [], + "kind": "function", + "name": "_refresh_cmd", + "parent_identity": null, + "qualified_name": "_refresh_cmd", + "signature": "def _refresh_cmd(args: argparse.Namespace) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 74, + "span": { + "end": { + "byte": 3075, + "column": 26, + "line": 74 + }, + "start": { + "byte": 2586, + "column": 0, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_refresh_cmd", + "identity": "_refresh_cmd", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_refresh_cmd/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_refresh_cmd", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "The exact command to regenerate this block, including non-default args.", + "text": "The exact command to regenerate this block, including non-default args." + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 65, + "span": { + "end": { + "byte": 2718, + "column": 81, + "line": 65 + }, + "start": { + "byte": 2641, + "column": 4, + "line": 65 + } + }, + "start_line": 65 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_refresh_cmd", + "identity": "_refresh_cmd", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_repository/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_repository", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_repository", + "decorators": [], + "kind": "function", + "name": "_repository", + "parent_identity": null, + "qualified_name": "_repository", + "signature": "def _repository(urls: dict) -> str | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 124, + "span": { + "end": { + "byte": 4548, + "column": 15, + "line": 124 + }, + "start": { + "byte": 4336, + "column": 0, + "line": 119 + } + }, + "start_line": 119 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_repository", + "identity": "_repository", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_scalar/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_scalar", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_scalar", + "decorators": [], + "kind": "function", + "name": "_scalar", + "parent_identity": null, + "qualified_name": "_scalar", + "signature": "def _scalar(value) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 178, + "span": { + "end": { + "byte": 6372, + "column": 42, + "line": 178 + }, + "start": { + "byte": 6303, + "column": 0, + "line": 177 + } + }, + "start_line": 177 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_scalar", + "identity": "_scalar", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_top_dirs/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_top_dirs", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:_top_dirs", + "decorators": [], + "kind": "function", + "name": "_top_dirs", + "parent_identity": null, + "qualified_name": "_top_dirs", + "signature": "def _top_dirs(root: Path) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 96, + "span": { + "end": { + "byte": 3794, + "column": 14, + "line": 96 + }, + "start": { + "byte": 3498, + "column": 0, + "line": 88 + } + }, + "start_line": 88 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/_top_dirs", + "identity": "_top_dirs", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/derive_facts/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "derive_facts", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:derive_facts", + "decorators": [], + "kind": "function", + "name": "derive_facts", + "parent_identity": null, + "qualified_name": "derive_facts", + "signature": "def derive_facts(root: Path, pyproject_rel: str) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 169, + "span": { + "end": { + "byte": 6135, + "column": 5, + "line": 169 + }, + "start": { + "byte": 4994, + "column": 0, + "line": 143 + } + }, + "start_line": 143 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/derive_facts", + "identity": "derive_facts", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: list[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 298, + "span": { + "end": { + "byte": 11227, + "column": 12, + "line": 298 + }, + "start": { + "byte": 9093, + "column": 0, + "line": 247 + } + }, + "start_line": 247 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/render/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "render", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:render", + "decorators": [], + "kind": "function", + "name": "render", + "parent_identity": null, + "qualified_name": "render", + "signature": "def render(facts: dict, refresh_cmd: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 222, + "span": { + "end": { + "byte": 8243, + "column": 27, + "line": 222 + }, + "start": { + "byte": 6596, + "column": 0, + "line": 187 + } + }, + "start_line": 187 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/render", + "identity": "render", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/splice/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "splice", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:splice", + "decorators": [], + "kind": "function", + "name": "splice", + "parent_identity": null, + "qualified_name": "splice", + "signature": "def splice(text: str, block: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 244, + "span": { + "end": { + "byte": 9090, + "column": 43, + "line": 244 + }, + "start": { + "byte": 8246, + "column": 0, + "line": 225 + } + }, + "start_line": 225 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/splice", + "identity": "splice", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/splice/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:manifest/generate.py::function:splice", + "description": "Fails loudly on a malformed doc (only one marker, or duplicates) so a broken\nblock is repaired rather than silently compounded by a second one.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Replace an existing manifest block, or append one if none is present.", + "text": "Replace an existing manifest block, or append one if none is present.\n\n Fails loudly on a malformed doc (only one marker, or duplicates) so a broken\n block is repaired rather than silently compounded by a second one.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "06cec293ebd7b9a04d84fbfcd4cee55ebb058b6f265e758b6acadd0efd86595d", + "file": "manifest/generate.py", + "location": { + "end_line": 230, + "span": { + "end": { + "byte": 8525, + "column": 7, + "line": 230 + }, + "start": { + "byte": 8292, + "column": 4, + "line": 226 + } + }, + "start_line": 226 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/manifest/generate.py#subject/symbol/splice", + "identity": "splice", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/meta-module-build/SKILL.md#subject/document/meta-module-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first module planning built on msdmd. Consume existing manifests, schemas and design declarations; supplemental MODULE_BUILD blocks record remaining purpose, surface, boundary, test, rollout and rollback obligations. Load this when turning a capability idea into a bounded module manifest and file plan before implementation.", + "name": "meta-module-build" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "f09cdc7b15a2a0a8f3f315743317aa1b89eeb458f436ae59c03228b4b52115dc", + "file": "meta-module-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/meta-module-build/SKILL.md#subject/document/meta-module-build%2FSKILL.md", + "identity": "meta-module-build/SKILL.md", + "scope": "document" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/meta/SKILL.md#subject/document/meta%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "METAPAT consultation router for The Interdependency. Load this when deciding which distinctions, relations, boundaries, transformations, scales, or cross-domain correspondences should organize downstream work; when examining available observations or metrics to determine which questions and projections are worth measuring; when the-interdependency skill's METAPAT consultation gate triggers; when an unresolved conceptual choice would constrain architecture, semantics, measurement, ontology, or later claims; or when explicitly asked to consult, apply, or interpret current METAPAT. Do not load merely for routine implementation under already-fixed conceptual contracts.", + "name": "meta" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "a11283b9f10a45a37518851f95015d0310771a4d6f7237b43be23db2a5e12412", + "file": "meta/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/meta/SKILL.md#subject/document/meta%2FSKILL.md", + "identity": "meta/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/SKILL.md#subject/document/msdmd%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Module Self-Declared Metadata in Markdown — native-first collection of metadata already expressed by code, documentation, manifests, schemas, tooling, and evidence formats, with MSDMD blocks only for otherwise unexpressed information. Load this when creating or revising metadata-driven skills, collecting repository metadata, integrating a metadata convention, building parsers or collection consumers, or auditing metadata coverage and provenance.", + "name": "msdmd" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "7b958e227edf4521d13bd529bf9b5028d8c5d75b7873c2a7f7b8ffd084252af4", + "file": "msdmd/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/SKILL.md#subject/document/msdmd%2FSKILL.md", + "identity": "msdmd/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "213:21" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A820-820/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "213:21" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 820, + "start_line": 820 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "17:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A820-820/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "17:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 820, + "start_line": 820 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "706:54" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A820-820/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "706:54" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 820, + "start_line": 820 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=706:54 imports_exports=17:5 calls_definitions=213:21" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 75, + "column": 75, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== DOCS ===\nid: msdmd_foundational_contract\n source: msdmd/SKILL.md\n catalogue: msdmd/references/metadata-conventions.md\n summary: Native-first metadata collection with source-qualified facts, diagnostics, and coverage policy. Supplemental blocks express otherwise unexpressed information.\n=== END DOCS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 7, + "span": { + "end": { + "byte": 398, + "column": 18, + "line": 7 + }, + "start": { + "byte": 76, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CAPABILITIES ===\nid: repo_collection_generator\n exposes: collect, render_typescript, collection_errors\n summary: Produces schema-2 collections from registered native readers and supplemental blocks without executing inspected sources.\n runner_scope: native-and-supplemental-blocks\n native_ingestion: implemented-tested-subsets\n limitations: Supported features and versions are reader-qualified; declarations and parsed reports do not prove runtime behavior. Required-source policy detects incomplete extraction.\n=== END CAPABILITIES ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 15, + "span": { + "end": { + "byte": 960, + "column": 26, + "line": 15 + }, + "start": { + "byte": 399, + "column": 0, + "line": 8 + } + }, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: msdmd_collection_generator\n module_name: collect\n module_kind: instrument\n summary: produces versioned native-first MSDMD collections without executing inspected sources\n owner: The Interdependency skill-lib\n public_surface: collect, collect_legacy, collection_errors, render_typescript\n internal_surface: bounded discovery, block identity validation, edge reconciliation, coverage accounting\n auth_boundary: none\n storage_boundary: read\n network_boundary: none\n user_data_boundary: read\n admin_only: false\n tests: tests/test_collect.py, tests/test_native_collection.py\n rollout: schema 2 is the default CLI output; --legacy-blocks-only keeps explicit schema 1 compatibility\n rollback: use --legacy-blocks-only while preserving schema incompatibility visibility\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 32, + "span": { + "end": { + "byte": 1820, + "column": 26, + "line": 32 + }, + "start": { + "byte": 961, + "column": 0, + "line": 16 + } + }, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=706:54 imports_exports=17:5 calls_definitions=213:21" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 820, + "span": { + "end": { + "byte": 37551, + "column": 75, + "line": 820 + }, + "start": { + "byte": 37476, + "column": 0, + "line": 820 + } + }, + "start_line": 820 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::<module>", + "description": "Usage guidance:\n python -m msdmd.collect --root . --repo owner/repo --out repo_msdmd.ts\n python -m msdmd.collect --root . --repo owner/repo --strict\n python -m msdmd.collect --root . --repo owner/repo --legacy-blocks-only\n\nThe default schema-2 path statically reads supported native conventions and\nsupplemental MSDMD blocks. It never imports inspected code, executes scripts,\nloads plugins, follows network references, or treats declarations as verified\nbehavior. The explicit legacy flag emits the previous block-only shape for old\nconsumers; it cannot silently represent native facts.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Generate a versioned native-first MSDMD collection.", + "text": "Generate a versioned native-first MSDMD collection.\n\nUsage guidance:\n python -m msdmd.collect --root . --repo owner/repo --out repo_msdmd.ts\n python -m msdmd.collect --root . --repo owner/repo --strict\n python -m msdmd.collect --root . --repo owner/repo --legacy-blocks-only\n\nThe default schema-2 path statically reads supported native conventions and\nsupplemental MSDMD blocks. It never imports inspected code, executes scripts,\nloads plugins, follows network references, or treats declarations as verified\nbehavior. The explicit legacy flag emits the previous block-only shape for old\nconsumers; it cannot silently represent native facts.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 45, + "span": { + "end": { + "byte": 2477, + "column": 3, + "line": 45 + }, + "start": { + "byte": 1821, + "column": 0, + "line": 33 + } + }, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 46, + "start_line": 46 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 48, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tokenize:tokenize:10", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tokenize", + "name": "tokenize" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 57, + "start_line": 57 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "collections:Counter:11", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "collections", + "name": "Counter" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 58, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/12", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "collections:defaultdict:12", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "collections", + "name": "defaultdict" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 58, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/13", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:13", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 59, + "start_line": 59 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/14", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:14", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 60, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/15", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterable:15", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 60, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/16", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "urllib.parse:quote:16", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "urllib.parse", + "name": "quote" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 61, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/17", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:marker_for:17", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "marker_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 63, + "start_line": 63 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/18", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:parse_text:18", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "parse_text" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 63, + "start_line": 63 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/19", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:READER_MANIFESTS:19", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "READER_MANIFESTS" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 64, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "fnmatch:fnmatch:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "fnmatch", + "name": "fnmatch" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 49, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/20", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_redact_sensitive:20", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_redact_sensitive" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 64, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/21", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:read_native:21", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "read_native" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 64, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 50, + "start_line": 50 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 51, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 52, + "start_line": 52 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:6", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 53, + "start_line": 53 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "stat:stat:7", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "stat", + "name": "stat" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 54, + "start_line": 54 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:8", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 55, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "io:io:9", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "io", + "name": "io" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 56, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/module/msdmd%2Fcollect.py", + "identity": "msdmd/collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_block_address/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_block_address", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_block_address", + "decorators": [], + "kind": "function", + "name": "_block_address", + "parent_identity": null, + "qualified_name": "_block_address", + "signature": "def _block_address(repo: str, revision: str, file: str, block: str, entry_id: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 156, + "span": { + "end": { + "byte": 5448, + "column": 5, + "line": 156 + }, + "start": { + "byte": 5207, + "column": 0, + "line": 152 + } + }, + "start_line": 152 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_block_address", + "identity": "_block_address", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_block_declaration/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_block_declaration", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_block_declaration", + "decorators": [], + "kind": "function", + "name": "_block_declaration", + "parent_identity": null, + "qualified_name": "_block_declaration", + "signature": "def _block_declaration(*, file: str, repo: str, revision: str, content_sha256: str, block: str, entry: dict[str, str]) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 184, + "span": { + "end": { + "byte": 6206, + "column": 5, + "line": 184 + }, + "start": { + "byte": 5451, + "column": 0, + "line": 159 + } + }, + "start_line": 159 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_block_declaration", + "identity": "_block_declaration", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_block_source_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_block_source_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_block_source_text", + "decorators": [], + "kind": "function", + "name": "_block_source_text", + "parent_identity": null, + "qualified_name": "_block_source_text", + "signature": "def _block_source_text(path: Path, text: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 141, + "span": { + "end": { + "byte": 4865, + "column": 30, + "line": 141 + }, + "start": { + "byte": 4071, + "column": 0, + "line": 124 + } + }, + "start_line": 124 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_block_source_text", + "identity": "_block_source_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_block_source_text/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_block_source_text", + "description": "The universal block grammar remains language-neutral. Python collection\nadds syntax awareness here so block-shaped examples inside strings are not\ncollected as declarations.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return only real Python comments, or unchanged non-Python source.", + "text": "Return only real Python comments, or unchanged non-Python source.\n\n The universal block grammar remains language-neutral. Python collection\n adds syntax awareness here so block-shaped examples inside strings are not\n collected as declarations.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 130, + "span": { + "end": { + "byte": 4392, + "column": 7, + "line": 130 + }, + "start": { + "byte": 4129, + "column": 4, + "line": 125 + } + }, + "start_line": 125 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_block_source_text", + "identity": "_block_source_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_decode_block_source/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_decode_block_source", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_decode_block_source", + "decorators": [], + "kind": "function", + "name": "_decode_block_source", + "parent_identity": null, + "qualified_name": "_decode_block_source", + "signature": "def _decode_block_source(path: Path, data: bytes) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 149, + "span": { + "end": { + "byte": 5204, + "column": 31, + "line": 149 + }, + "start": { + "byte": 4868, + "column": 0, + "line": 144 + } + }, + "start_line": 144 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_decode_block_source", + "identity": "_decode_block_source", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_decode_block_source/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_decode_block_source", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Decode Python by its declared source encoding; other sources as UTF-8.", + "text": "Decode Python by its declared source encoding; other sources as UTF-8." + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 145, + "span": { + "end": { + "byte": 5006, + "column": 80, + "line": 145 + }, + "start": { + "byte": 4930, + "column": 4, + "line": 145 + } + }, + "start_line": 145 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_decode_block_source", + "identity": "_decode_block_source", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_discover.excluded/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_discover.excluded", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_discover.excluded", + "decorators": [], + "kind": "function", + "name": "excluded", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_discover", + "qualified_name": "_discover.excluded", + "signature": "def excluded(relative: str, reason: str, *, entry_kind: str='file', digest: str='hmmm', size: int | None=None) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 252, + "span": { + "end": { + "byte": 8993, + "column": 27, + "line": 252 + }, + "start": { + "byte": 8619, + "column": 4, + "line": 247 + } + }, + "start_line": 247 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_discover.excluded", + "identity": "_discover.excluded", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_discover.failed/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_discover.failed", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_discover.failed", + "decorators": [], + "kind": "function", + "name": "failed", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_discover", + "qualified_name": "_discover.failed", + "signature": "def failed(relative: str, exc: Exception, entry_kind: str='file') -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 264, + "span": { + "end": { + "byte": 9730, + "column": 92, + "line": 264 + }, + "start": { + "byte": 9325, + "column": 4, + "line": 261 + } + }, + "start_line": 261 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_discover.failed", + "identity": "_discover.failed", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_discover.visit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_discover.visit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_discover.visit", + "decorators": [], + "kind": "function", + "name": "visit", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_discover", + "qualified_name": "_discover.visit", + "signature": "def visit(directory_fd: int, parent: str='') -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 316, + "span": { + "end": { + "byte": 12355, + "column": 37, + "line": 316 + }, + "start": { + "byte": 9736, + "column": 4, + "line": 266 + } + }, + "start_line": 266 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_discover.visit", + "identity": "_discover.visit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_discover/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_discover", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_discover", + "decorators": [], + "kind": "function", + "name": "_discover", + "parent_identity": null, + "qualified_name": "_discover", + "signature": "def _discover(root: Path, max_file_bytes: int, generated_outputs: Iterable[str]=(), *, stable_exclusions: bool=False) -> tuple[list, list, list]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 326, + "span": { + "end": { + "byte": 12643, + "column": 40, + "line": 326 + }, + "start": { + "byte": 8054, + "column": 0, + "line": 237 + } + }, + "start_line": 237 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_discover", + "identity": "_discover", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_discover/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_discover", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Read bounded files through directory descriptors; never follow symlinks.", + "text": "Read bounded files through directory descriptors; never follow symlinks." + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 238, + "span": { + "end": { + "byte": 8286, + "column": 82, + "line": 238 + }, + "start": { + "byte": 8208, + "column": 4, + "line": 238 + } + }, + "start_line": 238 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_discover", + "identity": "_discover", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_duplicate_diagnostics/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_duplicate_diagnostics", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_duplicate_diagnostics", + "decorators": [], + "kind": "function", + "name": "_duplicate_diagnostics", + "parent_identity": null, + "qualified_name": "_duplicate_diagnostics", + "signature": "def _duplicate_diagnostics(declarations: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 385, + "span": { + "end": { + "byte": 15093, + "column": 33, + "line": 385 + }, + "start": { + "byte": 13860, + "column": 0, + "line": 360 + } + }, + "start_line": 360 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_duplicate_diagnostics", + "identity": "_duplicate_diagnostics", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_git_identity/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_git_identity", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_git_identity", + "decorators": [], + "kind": "function", + "name": "_git_identity", + "parent_identity": null, + "qualified_name": "_git_identity", + "signature": "def _git_identity(root: Path, explicit_revision: str | None) -> tuple[str, bool | str, str | None]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 234, + "span": { + "end": { + "byte": 8051, + "column": 46, + "line": 234 + }, + "start": { + "byte": 6939, + "column": 0, + "line": 207 + } + }, + "start_line": 207 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_git_identity", + "identity": "_git_identity", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_native_identity_diagnostics/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_native_identity_diagnostics", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_native_identity_diagnostics", + "decorators": [], + "kind": "function", + "name": "_native_identity_diagnostics", + "parent_identity": null, + "qualified_name": "_native_identity_diagnostics", + "signature": "def _native_identity_diagnostics(facts: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 412, + "span": { + "end": { + "byte": 16254, + "column": 33, + "line": 412 + }, + "start": { + "byte": 15096, + "column": 0, + "line": 388 + } + }, + "start_line": 388 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_native_identity_diagnostics", + "identity": "_native_identity_diagnostics", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_quote/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_quote", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_quote", + "decorators": [], + "kind": "function", + "name": "_quote", + "parent_identity": null, + "qualified_name": "_quote", + "signature": "def _quote(value: str, *, path: bool=False) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 117, + "span": { + "end": { + "byte": 3950, + "column": 49, + "line": 117 + }, + "start": { + "byte": 3847, + "column": 0, + "line": 116 + } + }, + "start_line": 116 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_quote", + "identity": "_quote", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_raw_block_edges/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_raw_block_edges", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_raw_block_edges", + "decorators": [], + "kind": "function", + "name": "_raw_block_edges", + "parent_identity": null, + "qualified_name": "_raw_block_edges", + "signature": "def _raw_block_edges(declaration: dict[str, Any]) -> list[dict[str, Any]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 204, + "span": { + "end": { + "byte": 6936, + "column": 16, + "line": 204 + }, + "start": { + "byte": 6209, + "column": 0, + "line": 187 + } + }, + "start_line": 187 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_raw_block_edges", + "identity": "_raw_block_edges", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_reconcile_block_edges/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_reconcile_block_edges", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_reconcile_block_edges", + "decorators": [], + "kind": "function", + "name": "_reconcile_block_edges", + "parent_identity": null, + "qualified_name": "_reconcile_block_edges", + "signature": "def _reconcile_block_edges(raw_edges: list[dict[str, Any]], declarations: list[dict[str, Any]], diagnostics: list[dict[str, Any]]) -> list[dict[str, Any]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 357, + "span": { + "end": { + "byte": 13857, + "column": 16, + "line": 357 + }, + "start": { + "byte": 12646, + "column": 0, + "line": 329 + } + }, + "start_line": 329 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_reconcile_block_edges", + "identity": "_reconcile_block_edges", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_sha256/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_sha256", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_sha256", + "decorators": [], + "kind": "function", + "name": "_sha256", + "parent_identity": null, + "qualified_name": "_sha256", + "signature": "def _sha256(data: bytes | str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 113, + "span": { + "end": { + "byte": 3844, + "column": 46, + "line": 113 + }, + "start": { + "byte": 3687, + "column": 0, + "line": 111 + } + }, + "start_line": 111 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_sha256", + "identity": "_sha256", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_split_targets/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_split_targets", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:_split_targets", + "decorators": [], + "kind": "function", + "name": "_split_targets", + "parent_identity": null, + "qualified_name": "_split_targets", + "signature": "def _split_targets(value: str) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 121, + "span": { + "end": { + "byte": 4068, + "column": 70, + "line": 121 + }, + "start": { + "byte": 3953, + "column": 0, + "line": 120 + } + }, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/_split_targets", + "identity": "_split_targets", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collect/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "collect", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:collect", + "decorators": [], + "kind": "function", + "name": "collect", + "parent_identity": null, + "qualified_name": "collect", + "signature": "def collect(root: Path, repo: str, *, block_names: Iterable[str]=DEFAULT_BLOCK_NAMES, expected_blocks: Iterable[str]=(), source_commit: str | None=None, max_file_bytes: int=DEFAULT_MAX_FILE_BYTES, include_native: bool=True, snapshot_identity: bool=False, generated_outputs: Iterable[str]=(), required_sources: Iterable[str]=(), required_facts: Iterable[dict[str, str]]=()) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 671, + "span": { + "end": { + "byte": 29898, + "column": 5, + "line": 671 + }, + "start": { + "byte": 16257, + "column": 0, + "line": 415 + } + }, + "start_line": 415 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collect", + "identity": "collect", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collect/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:collect", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Collect native facts and supplemental blocks under ``root`` as schema 2.", + "text": "Collect native facts and supplemental blocks under ``root`` as schema 2." + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 429, + "span": { + "end": { + "byte": 16800, + "column": 82, + "line": 429 + }, + "start": { + "byte": 16722, + "column": 4, + "line": 429 + } + }, + "start_line": 429 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collect", + "identity": "collect", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collect_legacy/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "collect_legacy", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:collect_legacy", + "decorators": [], + "kind": "function", + "name": "collect_legacy", + "parent_identity": null, + "qualified_name": "collect_legacy", + "signature": "def collect_legacy(root: Path, repo: str, *, block_names: Iterable[str]=DEFAULT_BLOCK_NAMES, expected_blocks: Iterable[str]=(), source_commit: str | None=None) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 716, + "span": { + "end": { + "byte": 31405, + "column": 17, + "line": 716 + }, + "start": { + "byte": 29901, + "column": 0, + "line": 674 + } + }, + "start_line": 674 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collect_legacy", + "identity": "collect_legacy", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collect_legacy/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:collect_legacy", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Emit explicit schema-1 block-only compatibility output.", + "text": "Emit explicit schema-1 block-only compatibility output." + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 682, + "span": { + "end": { + "byte": 30178, + "column": 65, + "line": 682 + }, + "start": { + "byte": 30117, + "column": 4, + "line": 682 + } + }, + "start_line": 682 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collect_legacy", + "identity": "collect_legacy", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collection_errors/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "collection_errors", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:collection_errors", + "decorators": [], + "kind": "function", + "name": "collection_errors", + "parent_identity": null, + "qualified_name": "collection_errors", + "signature": "def collection_errors(collection: dict[str, Any]) -> list[dict[str, Any]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 721, + "span": { + "end": { + "byte": 31657, + "column": 98, + "line": 721 + }, + "start": { + "byte": 31408, + "column": 0, + "line": 719 + } + }, + "start_line": 719 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collection_errors", + "identity": "collection_errors", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collection_errors/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:collection_errors", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return diagnostics that invalidate collection identity or syntax.", + "text": "Return diagnostics that invalidate collection identity or syntax." + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 720, + "span": { + "end": { + "byte": 31558, + "column": 75, + "line": 720 + }, + "start": { + "byte": 31487, + "column": 4, + "line": 720 + } + }, + "start_line": 720 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/collection_errors", + "identity": "collection_errors", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main() -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 815, + "span": { + "end": { + "byte": 37417, + "column": 12, + "line": 815 + }, + "start": { + "byte": 33019, + "column": 0, + "line": 746 + } + }, + "start_line": 746 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/render_typescript/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:render_typescript", + "metadata_kind": "comment", + "text": "Bound TypeScript contextual inference without casts or losing type checks." + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 729, + "span": { + "end": { + "byte": 32127, + "column": 84, + "line": 729 + }, + "start": { + "byte": 32051, + "column": 8, + "line": 729 + } + }, + "start_line": 729 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/render_typescript", + "identity": "render_typescript", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/render_typescript/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "render_typescript", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:render_typescript", + "decorators": [], + "kind": "function", + "name": "render_typescript", + "parent_identity": null, + "qualified_name": "render_typescript", + "signature": "def render_typescript(collection: dict[str, Any], *, import_path: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 743, + "span": { + "end": { + "byte": 33016, + "column": 99, + "line": 743 + }, + "start": { + "byte": 31660, + "column": 0, + "line": 724 + } + }, + "start_line": 724 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/render_typescript", + "identity": "render_typescript", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/render_typescript/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/collect.py::function:render_typescript", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Render a schema-1 or schema-2 collection as a TypeScript module.", + "text": "Render a schema-1 or schema-2 collection as a TypeScript module." + } + }, + "origin": "native", + "source": { + "content_sha256": "13f8f549cfbead2b93320c5860ff94ca5a84259b24a4ed4a33459c7e7318b7e7", + "file": "msdmd/collect.py", + "location": { + "end_line": 725, + "span": { + "end": { + "byte": 31813, + "column": 74, + "line": 725 + }, + "start": { + "byte": 31743, + "column": 4, + "line": 725 + } + }, + "start_line": 725 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collect.py#subject/symbol/render_typescript", + "identity": "render_typescript", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A256-256/calls_definitions", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 256, + "start_line": 256 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A256-256/imports_exports", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 256, + "start_line": 256 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A256-256/loc_comments", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 256, + "start_line": 256 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts/fact/comment/lines%3A1-1/0", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "0", + "value": { + "attachment": "module-trivia", + "end_line": 1, + "identity": null, + "owner": null, + "start_line": 1, + "text": "// ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "identity": "msdmd/collection.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts/fact/comment/lines%3A2-11/1", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "1", + "value": { + "attachment": "module-trivia", + "end_line": 11, + "identity": null, + "owner": null, + "start_line": 2, + "text": "/**\n * Versioned TypeScript contracts for MSDMD collection points.\n *\n * Usage guidance:\n * - New native-capable generators call `defineMsdmdCollectionV2`.\n * - Existing block-only files may keep `defineMsdmdCollection` while they\n * explicitly remain schema 1.\n * - Consumers must negotiate `schema_version`; schema 1 cannot represent\n * native facts and must never receive a silent lossy projection.\n */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 11, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "identity": "msdmd/collection.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts/fact/comment/lines%3A243-243/5", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "5", + "value": { + "attachment": "module-trivia", + "end_line": 243, + "identity": null, + "owner": null, + "start_line": 243, + "text": "/** Explicit compatibility helper for block-only schema-1 collection points. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 243, + "start_line": 243 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "identity": "msdmd/collection.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts/fact/comment/lines%3A248-248/6", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "6", + "value": { + "attachment": "module-trivia", + "end_line": 248, + "identity": null, + "owner": null, + "start_line": 248, + "text": "/** Native-capable schema-2 helper. Consumers must opt into this exact version. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 248, + "start_line": 248 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "identity": "msdmd/collection.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts/fact/comment/lines%3A252-252/7", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "7", + "value": { + "attachment": "module-trivia", + "end_line": 252, + "identity": null, + "owner": null, + "start_line": 252, + "text": "/** Keep large generated literals type-checkable without any/unknown casts. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 252, + "start_line": 252 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "identity": "msdmd/collection.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts/fact/comment/lines%3A256-256/8", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "8", + "value": { + "attachment": "module-trivia", + "end_line": 256, + "identity": null, + "owner": null, + "start_line": 256, + "text": "// ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 256, + "start_line": 256 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "identity": "msdmd/collection.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts/fact/comment/lines%3A31-31/2", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "2", + "value": { + "attachment": "module-trivia", + "end_line": 31, + "identity": null, + "owner": null, + "start_line": 31, + "text": "/** Schema-1 block declaration retained only for explicit legacy consumers. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 31, + "start_line": 31 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "identity": "msdmd/collection.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts/fact/comment/lines%3A53-53/3", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "3", + "value": { + "attachment": "module-trivia", + "end_line": 53, + "identity": null, + "owner": null, + "start_line": 53, + "text": "/** Block-only schema. It cannot represent native facts. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 53, + "start_line": 53 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "identity": "msdmd/collection.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts/fact/comment/lines%3A64-64/4", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "4", + "value": { + "attachment": "module-trivia", + "end_line": 64, + "identity": null, + "owner": null, + "start_line": 64, + "text": "/** Explicit names retained for schema-1 source compatibility; never used for native facts. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 64, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/module/msdmd%2Fcollection.ts", + "identity": "msdmd/collection.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/JsonPrimitive%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "JsonPrimitive", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 13, + "exported": true, + "identity": "JsonPrimitive#0", + "kind": "TypeAliasDeclaration", + "name": "JsonPrimitive", + "parameters": [], + "qualified_name": "JsonPrimitive", + "returns": "string | number | boolean | null", + "start_line": 13 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/JsonPrimitive%230", + "identity": "JsonPrimitive#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/JsonPrimitive%230/fact/documentation/0", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.documentation-comment", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "description": "Versioned TypeScript contracts for MSDMD collection points.\n\nUsage guidance:\n- New native-capable generators call `defineMsdmdCollectionV2`.\n- Existing block-only files may keep `defineMsdmdCollection` while they\n explicitly remain schema 1.\n- Consumers must negotiate `schema_version`; schema 1 cannot represent\n native facts and must never receive a silent lossy projection.", + "end_line": 11, + "identity": "JsonPrimitive#0", + "owner": "JsonPrimitive", + "start_line": 2, + "tags": [], + "text": "/**\n * Versioned TypeScript contracts for MSDMD collection points.\n *\n * Usage guidance:\n * - New native-capable generators call `defineMsdmdCollectionV2`.\n * - Existing block-only files may keep `defineMsdmdCollection` while they\n * explicitly remain schema 1.\n * - Consumers must negotiate `schema_version`; schema 1 cannot represent\n * native facts and must never receive a silent lossy projection.\n */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 11, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/JsonPrimitive%230", + "identity": "JsonPrimitive#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/JsonValue%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "JsonValue", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 14, + "exported": true, + "identity": "JsonValue#0", + "kind": "TypeAliasDeclaration", + "name": "JsonValue", + "parameters": [], + "qualified_name": "JsonValue", + "returns": "JsonPrimitive | JsonValue[] | { [key: string]: JsonValue }", + "start_line": 14 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/JsonValue%230", + "identity": "JsonValue#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdBlockName%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdBlockName", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 27, + "exported": true, + "identity": "MsdmdBlockName#0", + "kind": "TypeAliasDeclaration", + "name": "MsdmdBlockName", + "parameters": [], + "qualified_name": "MsdmdBlockName", + "returns": "| \"DOCS\"\n | \"CAPABILITIES\"\n | \"DEPENDENCIES\"\n | \"OWNERS\"\n | \"CONTRACTS\"\n | \"CHECKS\"\n | \"MODULE_BUILD\"\n | \"BOUNDARIES\"\n | \"RATIOS\"\n | \"LLMS\"\n | \"FRONTEND_META\"", + "start_line": 16 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 27, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdBlockName%230", + "identity": "MsdmdBlockName#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollection%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdCollection", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 68, + "exported": true, + "identity": "MsdmdCollection#0", + "kind": "TypeAliasDeclaration", + "name": "MsdmdCollection", + "parameters": [], + "qualified_name": "MsdmdCollection", + "returns": "MsdmdCollectionV1", + "start_line": 68 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 68, + "start_line": 68 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollection%230", + "identity": "MsdmdCollection#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdCollectionV1", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 62, + "exported": true, + "identity": "MsdmdCollectionV1#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdCollectionV1", + "parameters": [], + "qualified_name": "MsdmdCollectionV1", + "returns": null, + "start_line": 54 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 62, + "start_line": 54 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1%230", + "identity": "MsdmdCollectionV1#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1%230/fact/documentation/2", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.documentation-comment", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "description": "Block-only schema. It cannot represent native facts.", + "end_line": 53, + "identity": "MsdmdCollectionV1#0", + "owner": "MsdmdCollectionV1", + "start_line": 53, + "tags": [], + "text": "/** Block-only schema. It cannot represent native facts. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 53, + "start_line": 53 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1%230", + "identity": "MsdmdCollectionV1#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.declarations%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV1.declarations", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 57, + "exported": false, + "identity": "MsdmdCollectionV1.declarations#0", + "kind": "PropertySignature", + "name": "declarations", + "parameters": [], + "qualified_name": "MsdmdCollectionV1.declarations", + "returns": "MsdmdDeclarationV1[]", + "start_line": 57 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 57, + "start_line": 57 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.declarations%230", + "identity": "MsdmdCollectionV1.declarations#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.edges%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV1.edges", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 59, + "exported": false, + "identity": "MsdmdCollectionV1.edges#0", + "kind": "PropertySignature", + "name": "edges", + "parameters": [], + "qualified_name": "MsdmdCollectionV1.edges", + "returns": "MsdmdEdgeV1[]", + "start_line": 59 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 59, + "start_line": 59 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.edges%230", + "identity": "MsdmdCollectionV1.edges#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.gaps%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV1.gaps", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 58, + "exported": false, + "identity": "MsdmdCollectionV1.gaps#0", + "kind": "PropertySignature", + "name": "gaps", + "parameters": [], + "qualified_name": "MsdmdCollectionV1.gaps", + "returns": "MsdmdGapV1[]", + "start_line": 58 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 58, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.gaps%230", + "identity": "MsdmdCollectionV1.gaps#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.generated_at%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV1.generated_at", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 60, + "exported": false, + "identity": "MsdmdCollectionV1.generated_at#0", + "kind": "PropertySignature", + "name": "generated_at", + "parameters": [], + "qualified_name": "MsdmdCollectionV1.generated_at", + "returns": "string", + "start_line": 60 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 60, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.generated_at%230", + "identity": "MsdmdCollectionV1.generated_at#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.repo%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV1.repo", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 56, + "exported": false, + "identity": "MsdmdCollectionV1.repo#0", + "kind": "PropertySignature", + "name": "repo", + "parameters": [], + "qualified_name": "MsdmdCollectionV1.repo", + "returns": "string", + "start_line": 56 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 56, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.repo%230", + "identity": "MsdmdCollectionV1.repo#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.schema_version%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV1.schema_version", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 55, + "exported": false, + "identity": "MsdmdCollectionV1.schema_version#0", + "kind": "PropertySignature", + "name": "schema_version", + "parameters": [], + "qualified_name": "MsdmdCollectionV1.schema_version", + "returns": "\"1.0.0\"", + "start_line": 55 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 55, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.schema_version%230", + "identity": "MsdmdCollectionV1.schema_version#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.source_commit%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV1.source_commit", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 61, + "exported": false, + "identity": "MsdmdCollectionV1.source_commit#0", + "kind": "PropertySignature", + "name": "source_commit", + "parameters": [], + "qualified_name": "MsdmdCollectionV1.source_commit", + "returns": "string", + "start_line": 61 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 61, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV1.source_commit%230", + "identity": "MsdmdCollectionV1.source_commit#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdCollectionV2", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 241, + "exported": true, + "identity": "MsdmdCollectionV2#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdCollectionV2", + "parameters": [], + "qualified_name": "MsdmdCollectionV2", + "returns": null, + "start_line": 199 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 241, + "start_line": 199 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2%230", + "identity": "MsdmdCollectionV2#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.capabilities%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.capabilities", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 202, + "exported": false, + "identity": "MsdmdCollectionV2.capabilities#0", + "kind": "PropertySignature", + "name": "capabilities", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.capabilities", + "returns": "string[]", + "start_line": 202 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 202, + "start_line": 202 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.capabilities%230", + "identity": "MsdmdCollectionV2.capabilities#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.conflicts%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.conflicts", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 223, + "exported": false, + "identity": "MsdmdCollectionV2.conflicts#0", + "kind": "PropertySignature", + "name": "conflicts", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.conflicts", + "returns": "MsdmdConflict[]", + "start_line": 223 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 223, + "start_line": 223 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.conflicts%230", + "identity": "MsdmdCollectionV2.conflicts#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 240, + "exported": false, + "identity": "MsdmdCollectionV2.coverage#0", + "kind": "PropertySignature", + "name": "coverage", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage", + "returns": "{\n denominator: { kind: \"discovered-files\"; count: number };\n excluded_subtrees?: number;\n required_sources?: string[];\n supported_files: number;\n partial_files: number;\n unsupported_files: number;\n invalid_files: number;\n excluded_files: number;\n unreadable_files: number;\n native_facts: number;\n supplemental_declarations: number;\n block_adoption: Record<string, number>;\n information_availability: \"not-evaluated-without-obligation-policy\" | \"policy-evaluated\";\n verified_behavior: \"not-evaluated\";\n }", + "start_line": 225 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 240, + "start_line": 225 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage%230", + "identity": "MsdmdCollectionV2.coverage#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.block_adoption%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.block_adoption", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 237, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.block_adoption#0", + "kind": "PropertySignature", + "name": "block_adoption", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.block_adoption", + "returns": "Record<string, number>", + "start_line": 237 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 237, + "start_line": 237 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.block_adoption%230", + "identity": "MsdmdCollectionV2.coverage.block_adoption#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.denominator%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.denominator", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 226, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.denominator#0", + "kind": "PropertySignature", + "name": "denominator", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.denominator", + "returns": "{ kind: \"discovered-files\"; count: number }", + "start_line": 226 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 226, + "start_line": 226 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.denominator%230", + "identity": "MsdmdCollectionV2.coverage.denominator#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.denominator.count%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.denominator.count", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 226, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.denominator.count#0", + "kind": "PropertySignature", + "name": "count", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.denominator.count", + "returns": "number", + "start_line": 226 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 226, + "start_line": 226 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.denominator.count%230", + "identity": "MsdmdCollectionV2.coverage.denominator.count#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.denominator.kind%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.denominator.kind", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 226, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.denominator.kind#0", + "kind": "PropertySignature", + "name": "kind", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.denominator.kind", + "returns": "\"discovered-files\"", + "start_line": 226 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 226, + "start_line": 226 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.denominator.kind%230", + "identity": "MsdmdCollectionV2.coverage.denominator.kind#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.excluded_files%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.excluded_files", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 233, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.excluded_files#0", + "kind": "PropertySignature", + "name": "excluded_files", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.excluded_files", + "returns": "number", + "start_line": 233 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 233, + "start_line": 233 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.excluded_files%230", + "identity": "MsdmdCollectionV2.coverage.excluded_files#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.excluded_subtrees%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.excluded_subtrees", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 227, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.excluded_subtrees#0", + "kind": "PropertySignature", + "name": "excluded_subtrees", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.excluded_subtrees", + "returns": "number", + "start_line": 227 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 227, + "start_line": 227 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.excluded_subtrees%230", + "identity": "MsdmdCollectionV2.coverage.excluded_subtrees#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.information_availability%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.information_availability", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 238, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.information_availability#0", + "kind": "PropertySignature", + "name": "information_availability", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.information_availability", + "returns": "\"not-evaluated-without-obligation-policy\" | \"policy-evaluated\"", + "start_line": 238 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 238, + "start_line": 238 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.information_availability%230", + "identity": "MsdmdCollectionV2.coverage.information_availability#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.invalid_files%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.invalid_files", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 232, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.invalid_files#0", + "kind": "PropertySignature", + "name": "invalid_files", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.invalid_files", + "returns": "number", + "start_line": 232 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 232, + "start_line": 232 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.invalid_files%230", + "identity": "MsdmdCollectionV2.coverage.invalid_files#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.native_facts%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.native_facts", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 235, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.native_facts#0", + "kind": "PropertySignature", + "name": "native_facts", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.native_facts", + "returns": "number", + "start_line": 235 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 235, + "start_line": 235 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.native_facts%230", + "identity": "MsdmdCollectionV2.coverage.native_facts#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.partial_files%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.partial_files", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 230, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.partial_files#0", + "kind": "PropertySignature", + "name": "partial_files", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.partial_files", + "returns": "number", + "start_line": 230 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 230, + "start_line": 230 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.partial_files%230", + "identity": "MsdmdCollectionV2.coverage.partial_files#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.required_sources%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.required_sources", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 228, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.required_sources#0", + "kind": "PropertySignature", + "name": "required_sources", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.required_sources", + "returns": "string[]", + "start_line": 228 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 228, + "start_line": 228 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.required_sources%230", + "identity": "MsdmdCollectionV2.coverage.required_sources#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.supplemental_declarations%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.supplemental_declarations", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 236, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.supplemental_declarations#0", + "kind": "PropertySignature", + "name": "supplemental_declarations", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.supplemental_declarations", + "returns": "number", + "start_line": 236 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 236, + "start_line": 236 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.supplemental_declarations%230", + "identity": "MsdmdCollectionV2.coverage.supplemental_declarations#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.supported_files%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.supported_files", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 229, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.supported_files#0", + "kind": "PropertySignature", + "name": "supported_files", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.supported_files", + "returns": "number", + "start_line": 229 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 229, + "start_line": 229 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.supported_files%230", + "identity": "MsdmdCollectionV2.coverage.supported_files#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.unreadable_files%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.unreadable_files", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 234, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.unreadable_files#0", + "kind": "PropertySignature", + "name": "unreadable_files", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.unreadable_files", + "returns": "number", + "start_line": 234 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 234, + "start_line": 234 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.unreadable_files%230", + "identity": "MsdmdCollectionV2.coverage.unreadable_files#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.unsupported_files%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.unsupported_files", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 231, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.unsupported_files#0", + "kind": "PropertySignature", + "name": "unsupported_files", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.unsupported_files", + "returns": "number", + "start_line": 231 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 231, + "start_line": 231 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.unsupported_files%230", + "identity": "MsdmdCollectionV2.coverage.unsupported_files#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.verified_behavior%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.coverage.verified_behavior", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 239, + "exported": false, + "identity": "MsdmdCollectionV2.coverage.verified_behavior#0", + "kind": "PropertySignature", + "name": "verified_behavior", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.coverage.verified_behavior", + "returns": "\"not-evaluated\"", + "start_line": 239 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 239, + "start_line": 239 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.coverage.verified_behavior%230", + "identity": "MsdmdCollectionV2.coverage.verified_behavior#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.declarations%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.declarations", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 219, + "exported": false, + "identity": "MsdmdCollectionV2.declarations#0", + "kind": "PropertySignature", + "name": "declarations", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.declarations", + "returns": "MsdmdDeclarationV2[]", + "start_line": 219 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 219, + "start_line": 219 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.declarations%230", + "identity": "MsdmdCollectionV2.declarations#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.diagnostics%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.diagnostics", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 224, + "exported": false, + "identity": "MsdmdCollectionV2.diagnostics#0", + "kind": "PropertySignature", + "name": "diagnostics", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.diagnostics", + "returns": "MsdmdDiagnostic[]", + "start_line": 224 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 224, + "start_line": 224 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.diagnostics%230", + "identity": "MsdmdCollectionV2.diagnostics#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.discovery%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.discovery", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 218, + "exported": false, + "identity": "MsdmdCollectionV2.discovery#0", + "kind": "PropertySignature", + "name": "discovery", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.discovery", + "returns": "MsdmdDiscoveryEntry[]", + "start_line": 218 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 218, + "start_line": 218 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.discovery%230", + "identity": "MsdmdCollectionV2.discovery#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.edges%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.edges", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 222, + "exported": false, + "identity": "MsdmdCollectionV2.edges#0", + "kind": "PropertySignature", + "name": "edges", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.edges", + "returns": "MsdmdEdgeV2[]", + "start_line": 222 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 222, + "start_line": 222 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.edges%230", + "identity": "MsdmdCollectionV2.edges#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.facts%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.facts", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 220, + "exported": false, + "identity": "MsdmdCollectionV2.facts#0", + "kind": "PropertySignature", + "name": "facts", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.facts", + "returns": "MsdmdNativeFact[]", + "start_line": 220 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 220, + "start_line": 220 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.facts%230", + "identity": "MsdmdCollectionV2.facts#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.gaps%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.gaps", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 221, + "exported": false, + "identity": "MsdmdCollectionV2.gaps#0", + "kind": "PropertySignature", + "name": "gaps", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.gaps", + "returns": "MsdmdGapV2[]", + "start_line": 221 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 221, + "start_line": 221 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.gaps%230", + "identity": "MsdmdCollectionV2.gaps#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.reader_manifests%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.reader_manifests", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 216, + "exported": false, + "identity": "MsdmdCollectionV2.reader_manifests#0", + "kind": "PropertySignature", + "name": "reader_manifests", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.reader_manifests", + "returns": "MsdmdReaderManifest[]", + "start_line": 216 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 216, + "start_line": 216 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.reader_manifests%230", + "identity": "MsdmdCollectionV2.reader_manifests#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.reader_runs%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.reader_runs", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 217, + "exported": false, + "identity": "MsdmdCollectionV2.reader_runs#0", + "kind": "PropertySignature", + "name": "reader_runs", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.reader_runs", + "returns": "MsdmdReaderRun[]", + "start_line": 217 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 217, + "start_line": 217 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.reader_runs%230", + "identity": "MsdmdCollectionV2.reader_runs#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.repo%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.repo", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 203, + "exported": false, + "identity": "MsdmdCollectionV2.repo#0", + "kind": "PropertySignature", + "name": "repo", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.repo", + "returns": "string", + "start_line": 203 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 203, + "start_line": 203 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.repo%230", + "identity": "MsdmdCollectionV2.repo#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.requirements%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.requirements", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 215, + "exported": false, + "identity": "MsdmdCollectionV2.requirements#0", + "kind": "PropertySignature", + "name": "requirements", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.requirements", + "returns": "JsonValue[]", + "start_line": 215 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 215, + "start_line": 215 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.requirements%230", + "identity": "MsdmdCollectionV2.requirements#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.schema%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.schema", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 200, + "exported": false, + "identity": "MsdmdCollectionV2.schema#0", + "kind": "PropertySignature", + "name": "schema", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.schema", + "returns": "\"the-interdependency.msdmd-collection\"", + "start_line": 200 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 200, + "start_line": 200 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.schema%230", + "identity": "MsdmdCollectionV2.schema#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.schema_version%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.schema_version", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 201, + "exported": false, + "identity": "MsdmdCollectionV2.schema_version#0", + "kind": "PropertySignature", + "name": "schema_version", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.schema_version", + "returns": "\"2.0.0\"", + "start_line": 201 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 201, + "start_line": 201 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.schema_version%230", + "identity": "MsdmdCollectionV2.schema_version#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.source", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 214, + "exported": false, + "identity": "MsdmdCollectionV2.source#0", + "kind": "PropertySignature", + "name": "source", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.source", + "returns": "{\n repository: string;\n revision: string;\n git_head: string;\n dirty_worktree: boolean | \"hmmm\";\n snapshot_sha256: string;\n snapshot_complete: boolean;\n revision_kind?: \"content-snapshot\" | \"git-or-declared\";\n exclusion_accounting?: \"configured-patterns\" | \"observed-paths\";\n scope?: string;\n }", + "start_line": 204 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 214, + "start_line": 204 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source%230", + "identity": "MsdmdCollectionV2.source#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.dirty_worktree%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.source.dirty_worktree", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 208, + "exported": false, + "identity": "MsdmdCollectionV2.source.dirty_worktree#0", + "kind": "PropertySignature", + "name": "dirty_worktree", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.source.dirty_worktree", + "returns": "boolean | \"hmmm\"", + "start_line": 208 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 208, + "start_line": 208 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.dirty_worktree%230", + "identity": "MsdmdCollectionV2.source.dirty_worktree#0", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.exclusion_accounting%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.source.exclusion_accounting", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 212, + "exported": false, + "identity": "MsdmdCollectionV2.source.exclusion_accounting#0", + "kind": "PropertySignature", + "name": "exclusion_accounting", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.source.exclusion_accounting", + "returns": "\"configured-patterns\" | \"observed-paths\"", + "start_line": 212 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 212, + "start_line": 212 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.exclusion_accounting%230", + "identity": "MsdmdCollectionV2.source.exclusion_accounting#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.git_head%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.source.git_head", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 207, + "exported": false, + "identity": "MsdmdCollectionV2.source.git_head#0", + "kind": "PropertySignature", + "name": "git_head", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.source.git_head", + "returns": "string", + "start_line": 207 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 207, + "start_line": 207 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.git_head%230", + "identity": "MsdmdCollectionV2.source.git_head#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.repository%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.source.repository", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 205, + "exported": false, + "identity": "MsdmdCollectionV2.source.repository#0", + "kind": "PropertySignature", + "name": "repository", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.source.repository", + "returns": "string", + "start_line": 205 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 205, + "start_line": 205 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.repository%230", + "identity": "MsdmdCollectionV2.source.repository#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.revision%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.source.revision", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 206, + "exported": false, + "identity": "MsdmdCollectionV2.source.revision#0", + "kind": "PropertySignature", + "name": "revision", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.source.revision", + "returns": "string", + "start_line": 206 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 206, + "start_line": 206 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.revision%230", + "identity": "MsdmdCollectionV2.source.revision#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.revision_kind%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.source.revision_kind", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 211, + "exported": false, + "identity": "MsdmdCollectionV2.source.revision_kind#0", + "kind": "PropertySignature", + "name": "revision_kind", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.source.revision_kind", + "returns": "\"content-snapshot\" | \"git-or-declared\"", + "start_line": 211 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 211, + "start_line": 211 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.revision_kind%230", + "identity": "MsdmdCollectionV2.source.revision_kind#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.scope%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.source.scope", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 213, + "exported": false, + "identity": "MsdmdCollectionV2.source.scope#0", + "kind": "PropertySignature", + "name": "scope", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.source.scope", + "returns": "string", + "start_line": 213 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 213, + "start_line": 213 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.scope%230", + "identity": "MsdmdCollectionV2.source.scope#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.snapshot_complete%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.source.snapshot_complete", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 210, + "exported": false, + "identity": "MsdmdCollectionV2.source.snapshot_complete#0", + "kind": "PropertySignature", + "name": "snapshot_complete", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.source.snapshot_complete", + "returns": "boolean", + "start_line": 210 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 210, + "start_line": 210 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.snapshot_complete%230", + "identity": "MsdmdCollectionV2.source.snapshot_complete#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.snapshot_sha256%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdCollectionV2.source.snapshot_sha256", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 209, + "exported": false, + "identity": "MsdmdCollectionV2.source.snapshot_sha256#0", + "kind": "PropertySignature", + "name": "snapshot_sha256", + "parameters": [], + "qualified_name": "MsdmdCollectionV2.source.snapshot_sha256", + "returns": "string", + "start_line": 209 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 209, + "start_line": 209 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdCollectionV2.source.snapshot_sha256%230", + "identity": "MsdmdCollectionV2.source.snapshot_sha256#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdConflict", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 191, + "exported": true, + "identity": "MsdmdConflict#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdConflict", + "parameters": [], + "qualified_name": "MsdmdConflict", + "returns": null, + "start_line": 185 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 191, + "start_line": 185 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict%230", + "identity": "MsdmdConflict#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict.identity%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdConflict.identity", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 188, + "exported": false, + "identity": "MsdmdConflict.identity#0", + "kind": "PropertySignature", + "name": "identity", + "parameters": [], + "qualified_name": "MsdmdConflict.identity", + "returns": "string", + "start_line": 188 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 188, + "start_line": 188 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict.identity%230", + "identity": "MsdmdConflict.identity#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict.kind%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdConflict.kind", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 186, + "exported": false, + "identity": "MsdmdConflict.kind#0", + "kind": "PropertySignature", + "name": "kind", + "parameters": [], + "qualified_name": "MsdmdConflict.kind", + "returns": "string", + "start_line": 186 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 186, + "start_line": 186 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict.kind%230", + "identity": "MsdmdConflict.kind#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict.reason%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdConflict.reason", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 190, + "exported": false, + "identity": "MsdmdConflict.reason#0", + "kind": "PropertySignature", + "name": "reason", + "parameters": [], + "qualified_name": "MsdmdConflict.reason", + "returns": "string", + "start_line": 190 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 190, + "start_line": 190 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict.reason%230", + "identity": "MsdmdConflict.reason#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict.status%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdConflict.status", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 187, + "exported": false, + "identity": "MsdmdConflict.status#0", + "kind": "PropertySignature", + "name": "status", + "parameters": [], + "qualified_name": "MsdmdConflict.status", + "returns": "\"unresolved\" | \"resolved\"", + "start_line": 187 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 187, + "start_line": 187 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict.status%230", + "identity": "MsdmdConflict.status#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict.witnesses%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdConflict.witnesses", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 189, + "exported": false, + "identity": "MsdmdConflict.witnesses#0", + "kind": "PropertySignature", + "name": "witnesses", + "parameters": [], + "qualified_name": "MsdmdConflict.witnesses", + "returns": "MsdmdSourceReference[]", + "start_line": 189 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 189, + "start_line": 189 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdConflict.witnesses%230", + "identity": "MsdmdConflict.witnesses#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclaration%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdDeclaration", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 65, + "exported": true, + "identity": "MsdmdDeclaration#0", + "kind": "TypeAliasDeclaration", + "name": "MsdmdDeclaration", + "parameters": [], + "qualified_name": "MsdmdDeclaration", + "returns": "MsdmdDeclarationV1", + "start_line": 65 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 65, + "start_line": 65 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclaration%230", + "identity": "MsdmdDeclaration#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclaration%230/fact/documentation/3", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.documentation-comment", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "description": "Explicit names retained for schema-1 source compatibility; never used for native facts.", + "end_line": 64, + "identity": "MsdmdDeclaration#0", + "owner": "MsdmdDeclaration", + "start_line": 64, + "tags": [], + "text": "/** Explicit names retained for schema-1 source compatibility; never used for native facts. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 64, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclaration%230", + "identity": "MsdmdDeclaration#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdDeclarationV1", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 37, + "exported": true, + "identity": "MsdmdDeclarationV1#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdDeclarationV1", + "parameters": [], + "qualified_name": "MsdmdDeclarationV1", + "returns": null, + "start_line": 32 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 37, + "start_line": 32 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1%230", + "identity": "MsdmdDeclarationV1#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1%230/fact/documentation/1", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.documentation-comment", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "description": "Schema-1 block declaration retained only for explicit legacy consumers.", + "end_line": 31, + "identity": "MsdmdDeclarationV1#0", + "owner": "MsdmdDeclarationV1", + "start_line": 31, + "tags": [], + "text": "/** Schema-1 block declaration retained only for explicit legacy consumers. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 31, + "start_line": 31 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1%230", + "identity": "MsdmdDeclarationV1#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1.block%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV1.block", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 34, + "exported": false, + "identity": "MsdmdDeclarationV1.block#0", + "kind": "PropertySignature", + "name": "block", + "parameters": [], + "qualified_name": "MsdmdDeclarationV1.block", + "returns": "MsdmdBlockName", + "start_line": 34 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 34, + "start_line": 34 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1.block%230", + "identity": "MsdmdDeclarationV1.block#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1.fields%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV1.fields", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 36, + "exported": false, + "identity": "MsdmdDeclarationV1.fields#0", + "kind": "PropertySignature", + "name": "fields", + "parameters": [], + "qualified_name": "MsdmdDeclarationV1.fields", + "returns": "MsdmdFieldMap", + "start_line": 36 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 36, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1.fields%230", + "identity": "MsdmdDeclarationV1.fields#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1.file%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV1.file", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 33, + "exported": false, + "identity": "MsdmdDeclarationV1.file#0", + "kind": "PropertySignature", + "name": "file", + "parameters": [], + "qualified_name": "MsdmdDeclarationV1.file", + "returns": "string", + "start_line": 33 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 33, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1.file%230", + "identity": "MsdmdDeclarationV1.file#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1.id%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV1.id", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 35, + "exported": false, + "identity": "MsdmdDeclarationV1.id#0", + "kind": "PropertySignature", + "name": "id", + "parameters": [], + "qualified_name": "MsdmdDeclarationV1.id", + "returns": "string", + "start_line": 35 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 35, + "start_line": 35 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV1.id%230", + "identity": "MsdmdDeclarationV1.id#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdDeclarationV2", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 91, + "exported": true, + "identity": "MsdmdDeclarationV2#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdDeclarationV2", + "parameters": [], + "qualified_name": "MsdmdDeclarationV2", + "returns": null, + "start_line": 82 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 91, + "start_line": 82 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2%230", + "identity": "MsdmdDeclarationV2#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.address%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV2.address", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 83, + "exported": false, + "identity": "MsdmdDeclarationV2.address#0", + "kind": "PropertySignature", + "name": "address", + "parameters": [], + "qualified_name": "MsdmdDeclarationV2.address", + "returns": "string", + "start_line": 83 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 83, + "start_line": 83 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.address%230", + "identity": "MsdmdDeclarationV2.address#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.block%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV2.block", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 88, + "exported": false, + "identity": "MsdmdDeclarationV2.block#0", + "kind": "PropertySignature", + "name": "block", + "parameters": [], + "qualified_name": "MsdmdDeclarationV2.block", + "returns": "MsdmdBlockName", + "start_line": 88 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 88, + "start_line": 88 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.block%230", + "identity": "MsdmdDeclarationV2.block#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.fields%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV2.fields", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 90, + "exported": false, + "identity": "MsdmdDeclarationV2.fields#0", + "kind": "PropertySignature", + "name": "fields", + "parameters": [], + "qualified_name": "MsdmdDeclarationV2.fields", + "returns": "MsdmdFieldMap", + "start_line": 90 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 90, + "start_line": 90 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.fields%230", + "identity": "MsdmdDeclarationV2.fields#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.file%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV2.file", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 87, + "exported": false, + "identity": "MsdmdDeclarationV2.file#0", + "kind": "PropertySignature", + "name": "file", + "parameters": [], + "qualified_name": "MsdmdDeclarationV2.file", + "returns": "string", + "start_line": 87 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 87, + "start_line": 87 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.file%230", + "identity": "MsdmdDeclarationV2.file#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.id%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV2.id", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 89, + "exported": false, + "identity": "MsdmdDeclarationV2.id#0", + "kind": "PropertySignature", + "name": "id", + "parameters": [], + "qualified_name": "MsdmdDeclarationV2.id", + "returns": "string", + "start_line": 89 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 89, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.id%230", + "identity": "MsdmdDeclarationV2.id#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.origin%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV2.origin", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 84, + "exported": false, + "identity": "MsdmdDeclarationV2.origin#0", + "kind": "PropertySignature", + "name": "origin", + "parameters": [], + "qualified_name": "MsdmdDeclarationV2.origin", + "returns": "\"msdmd-block\"", + "start_line": 84 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 84, + "start_line": 84 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.origin%230", + "identity": "MsdmdDeclarationV2.origin#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.source%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV2.source", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 86, + "exported": false, + "identity": "MsdmdDeclarationV2.source#0", + "kind": "PropertySignature", + "name": "source", + "parameters": [], + "qualified_name": "MsdmdDeclarationV2.source", + "returns": "MsdmdSourceReference", + "start_line": 86 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 86, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.source%230", + "identity": "MsdmdDeclarationV2.source#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.standing%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDeclarationV2.standing", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 85, + "exported": false, + "identity": "MsdmdDeclarationV2.standing#0", + "kind": "PropertySignature", + "name": "standing", + "parameters": [], + "qualified_name": "MsdmdDeclarationV2.standing", + "returns": "\"declared\"", + "start_line": 85 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 85, + "start_line": 85 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDeclarationV2.standing%230", + "identity": "MsdmdDeclarationV2.standing#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdDiagnostic", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 183, + "exported": true, + "identity": "MsdmdDiagnostic#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdDiagnostic", + "parameters": [], + "qualified_name": "MsdmdDiagnostic", + "returns": null, + "start_line": 175 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 183, + "start_line": 175 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic%230", + "identity": "MsdmdDiagnostic#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.candidates%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiagnostic.candidates", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 182, + "exported": false, + "identity": "MsdmdDiagnostic.candidates#0", + "kind": "PropertySignature", + "name": "candidates", + "parameters": [], + "qualified_name": "MsdmdDiagnostic.candidates", + "returns": "string[]", + "start_line": 182 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 182, + "start_line": 182 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.candidates%230", + "identity": "MsdmdDiagnostic.candidates#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.code%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiagnostic.code", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 176, + "exported": false, + "identity": "MsdmdDiagnostic.code#0", + "kind": "PropertySignature", + "name": "code", + "parameters": [], + "qualified_name": "MsdmdDiagnostic.code", + "returns": "string", + "start_line": 176 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 176, + "start_line": 176 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.code%230", + "identity": "MsdmdDiagnostic.code#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.message%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiagnostic.message", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 179, + "exported": false, + "identity": "MsdmdDiagnostic.message#0", + "kind": "PropertySignature", + "name": "message", + "parameters": [], + "qualified_name": "MsdmdDiagnostic.message", + "returns": "string", + "start_line": 179 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 179, + "start_line": 179 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.message%230", + "identity": "MsdmdDiagnostic.message#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.reader_id%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiagnostic.reader_id", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 181, + "exported": false, + "identity": "MsdmdDiagnostic.reader_id#0", + "kind": "PropertySignature", + "name": "reader_id", + "parameters": [], + "qualified_name": "MsdmdDiagnostic.reader_id", + "returns": "string | null", + "start_line": 181 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 181, + "start_line": 181 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.reader_id%230", + "identity": "MsdmdDiagnostic.reader_id#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.severity%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiagnostic.severity", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 177, + "exported": false, + "identity": "MsdmdDiagnostic.severity#0", + "kind": "PropertySignature", + "name": "severity", + "parameters": [], + "qualified_name": "MsdmdDiagnostic.severity", + "returns": "\"error\" | \"warning\" | \"info\"", + "start_line": 177 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 177, + "start_line": 177 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.severity%230", + "identity": "MsdmdDiagnostic.severity#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.source%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiagnostic.source", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 180, + "exported": false, + "identity": "MsdmdDiagnostic.source#0", + "kind": "PropertySignature", + "name": "source", + "parameters": [], + "qualified_name": "MsdmdDiagnostic.source", + "returns": "JsonValue", + "start_line": 180 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 180, + "start_line": 180 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.source%230", + "identity": "MsdmdDiagnostic.source#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.status%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiagnostic.status", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 178, + "exported": false, + "identity": "MsdmdDiagnostic.status#0", + "kind": "PropertySignature", + "name": "status", + "parameters": [], + "qualified_name": "MsdmdDiagnostic.status", + "returns": "string", + "start_line": 178 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 178, + "start_line": 178 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiagnostic.status%230", + "identity": "MsdmdDiagnostic.status#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdDiscoveryEntry", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 162, + "exported": true, + "identity": "MsdmdDiscoveryEntry#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdDiscoveryEntry", + "parameters": [], + "qualified_name": "MsdmdDiscoveryEntry", + "returns": null, + "start_line": 154 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 162, + "start_line": 154 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry%230", + "identity": "MsdmdDiscoveryEntry#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.content_sha256%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiscoveryEntry.content_sha256", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 158, + "exported": false, + "identity": "MsdmdDiscoveryEntry.content_sha256#0", + "kind": "PropertySignature", + "name": "content_sha256", + "parameters": [], + "qualified_name": "MsdmdDiscoveryEntry.content_sha256", + "returns": "string", + "start_line": 158 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 158, + "start_line": 158 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.content_sha256%230", + "identity": "MsdmdDiscoveryEntry.content_sha256#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.entry_kind%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiscoveryEntry.entry_kind", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 159, + "exported": false, + "identity": "MsdmdDiscoveryEntry.entry_kind#0", + "kind": "PropertySignature", + "name": "entry_kind", + "parameters": [], + "qualified_name": "MsdmdDiscoveryEntry.entry_kind", + "returns": "\"file\" | \"subtree\" | \"output\"", + "start_line": 159 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 159, + "start_line": 159 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.entry_kind%230", + "identity": "MsdmdDiscoveryEntry.entry_kind#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.file%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiscoveryEntry.file", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 155, + "exported": false, + "identity": "MsdmdDiscoveryEntry.file#0", + "kind": "PropertySignature", + "name": "file", + "parameters": [], + "qualified_name": "MsdmdDiscoveryEntry.file", + "returns": "string", + "start_line": 155 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 155, + "start_line": 155 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.file%230", + "identity": "MsdmdDiscoveryEntry.file#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.reader_ids%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiscoveryEntry.reader_ids", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 157, + "exported": false, + "identity": "MsdmdDiscoveryEntry.reader_ids#0", + "kind": "PropertySignature", + "name": "reader_ids", + "parameters": [], + "qualified_name": "MsdmdDiscoveryEntry.reader_ids", + "returns": "string[]", + "start_line": 157 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 157, + "start_line": 157 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.reader_ids%230", + "identity": "MsdmdDiscoveryEntry.reader_ids#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.reason%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiscoveryEntry.reason", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 161, + "exported": false, + "identity": "MsdmdDiscoveryEntry.reason#0", + "kind": "PropertySignature", + "name": "reason", + "parameters": [], + "qualified_name": "MsdmdDiscoveryEntry.reason", + "returns": "string", + "start_line": 161 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 161, + "start_line": 161 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.reason%230", + "identity": "MsdmdDiscoveryEntry.reason#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.size%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiscoveryEntry.size", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 160, + "exported": false, + "identity": "MsdmdDiscoveryEntry.size#0", + "kind": "PropertySignature", + "name": "size", + "parameters": [], + "qualified_name": "MsdmdDiscoveryEntry.size", + "returns": "number", + "start_line": 160 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 160, + "start_line": 160 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.size%230", + "identity": "MsdmdDiscoveryEntry.size#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.status%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdDiscoveryEntry.status", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 156, + "exported": false, + "identity": "MsdmdDiscoveryEntry.status#0", + "kind": "PropertySignature", + "name": "status", + "parameters": [], + "qualified_name": "MsdmdDiscoveryEntry.status", + "returns": "\"supported\" | \"partial\" | \"unsupported\" | \"invalid\" | \"excluded\" | \"unreadable\"", + "start_line": 156 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 156, + "start_line": 156 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdDiscoveryEntry.status%230", + "identity": "MsdmdDiscoveryEntry.status#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdge%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdEdge", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 67, + "exported": true, + "identity": "MsdmdEdge#0", + "kind": "TypeAliasDeclaration", + "name": "MsdmdEdge", + "parameters": [], + "qualified_name": "MsdmdEdge", + "returns": "MsdmdEdgeV1", + "start_line": 67 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 67, + "start_line": 67 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdge%230", + "identity": "MsdmdEdge#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdEdgeV1", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 51, + "exported": true, + "identity": "MsdmdEdgeV1#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdEdgeV1", + "parameters": [], + "qualified_name": "MsdmdEdgeV1", + "returns": null, + "start_line": 45 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 51, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1%230", + "identity": "MsdmdEdgeV1#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1.from%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV1.from", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 46, + "exported": false, + "identity": "MsdmdEdgeV1.from#0", + "kind": "PropertySignature", + "name": "from", + "parameters": [], + "qualified_name": "MsdmdEdgeV1.from", + "returns": "string", + "start_line": 46 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 46, + "start_line": 46 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1.from%230", + "identity": "MsdmdEdgeV1.from#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1.kind%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV1.kind", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 48, + "exported": false, + "identity": "MsdmdEdgeV1.kind#0", + "kind": "PropertySignature", + "name": "kind", + "parameters": [], + "qualified_name": "MsdmdEdgeV1.kind", + "returns": "string", + "start_line": 48 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 48, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1.kind%230", + "identity": "MsdmdEdgeV1.kind#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1.source_block%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV1.source_block", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 49, + "exported": false, + "identity": "MsdmdEdgeV1.source_block#0", + "kind": "PropertySignature", + "name": "source_block", + "parameters": [], + "qualified_name": "MsdmdEdgeV1.source_block", + "returns": "MsdmdBlockName", + "start_line": 49 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 49, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1.source_block%230", + "identity": "MsdmdEdgeV1.source_block#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1.source_id%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV1.source_id", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 50, + "exported": false, + "identity": "MsdmdEdgeV1.source_id#0", + "kind": "PropertySignature", + "name": "source_id", + "parameters": [], + "qualified_name": "MsdmdEdgeV1.source_id", + "returns": "string", + "start_line": 50 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 50, + "start_line": 50 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1.source_id%230", + "identity": "MsdmdEdgeV1.source_id#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1.to%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV1.to", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 47, + "exported": false, + "identity": "MsdmdEdgeV1.to#0", + "kind": "PropertySignature", + "name": "to", + "parameters": [], + "qualified_name": "MsdmdEdgeV1.to", + "returns": "string", + "start_line": 47 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 47, + "start_line": 47 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV1.to%230", + "identity": "MsdmdEdgeV1.to#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdEdgeV2", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 173, + "exported": true, + "identity": "MsdmdEdgeV2#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdEdgeV2", + "parameters": [], + "qualified_name": "MsdmdEdgeV2", + "returns": null, + "start_line": 164 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 173, + "start_line": 164 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2%230", + "identity": "MsdmdEdgeV2#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.from%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV2.from", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 165, + "exported": false, + "identity": "MsdmdEdgeV2.from#0", + "kind": "PropertySignature", + "name": "from", + "parameters": [], + "qualified_name": "MsdmdEdgeV2.from", + "returns": "string", + "start_line": 165 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 165, + "start_line": 165 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.from%230", + "identity": "MsdmdEdgeV2.from#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.kind%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV2.kind", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 167, + "exported": false, + "identity": "MsdmdEdgeV2.kind#0", + "kind": "PropertySignature", + "name": "kind", + "parameters": [], + "qualified_name": "MsdmdEdgeV2.kind", + "returns": "string", + "start_line": 167 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 167, + "start_line": 167 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.kind%230", + "identity": "MsdmdEdgeV2.kind#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.source_block%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV2.source_block", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 170, + "exported": false, + "identity": "MsdmdEdgeV2.source_block#0", + "kind": "PropertySignature", + "name": "source_block", + "parameters": [], + "qualified_name": "MsdmdEdgeV2.source_block", + "returns": "MsdmdBlockName", + "start_line": 170 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 170, + "start_line": 170 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.source_block%230", + "identity": "MsdmdEdgeV2.source_block#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.source_entry_id%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV2.source_entry_id", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 172, + "exported": false, + "identity": "MsdmdEdgeV2.source_entry_id#0", + "kind": "PropertySignature", + "name": "source_entry_id", + "parameters": [], + "qualified_name": "MsdmdEdgeV2.source_entry_id", + "returns": "string", + "start_line": 172 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 172, + "start_line": 172 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.source_entry_id%230", + "identity": "MsdmdEdgeV2.source_entry_id#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.source_id%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV2.source_id", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 171, + "exported": false, + "identity": "MsdmdEdgeV2.source_id#0", + "kind": "PropertySignature", + "name": "source_id", + "parameters": [], + "qualified_name": "MsdmdEdgeV2.source_id", + "returns": "string", + "start_line": 171 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 171, + "start_line": 171 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.source_id%230", + "identity": "MsdmdEdgeV2.source_id#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.standing%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV2.standing", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 168, + "exported": false, + "identity": "MsdmdEdgeV2.standing#0", + "kind": "PropertySignature", + "name": "standing", + "parameters": [], + "qualified_name": "MsdmdEdgeV2.standing", + "returns": "\"declared\" | \"syntactically-observed\" | \"derived\" | \"reported-evidence\"", + "start_line": 168 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 168, + "start_line": 168 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.standing%230", + "identity": "MsdmdEdgeV2.standing#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.target_resolution%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV2.target_resolution", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 169, + "exported": false, + "identity": "MsdmdEdgeV2.target_resolution#0", + "kind": "PropertySignature", + "name": "target_resolution", + "parameters": [], + "qualified_name": "MsdmdEdgeV2.target_resolution", + "returns": "\"resolved-unique-entry-id\" | \"external-or-unresolved\" | \"ambiguous\"", + "start_line": 169 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 169, + "start_line": 169 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.target_resolution%230", + "identity": "MsdmdEdgeV2.target_resolution#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.to%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdEdgeV2.to", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 166, + "exported": false, + "identity": "MsdmdEdgeV2.to#0", + "kind": "PropertySignature", + "name": "to", + "parameters": [], + "qualified_name": "MsdmdEdgeV2.to", + "returns": "string", + "start_line": 166 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 166, + "start_line": 166 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdEdgeV2.to%230", + "identity": "MsdmdEdgeV2.to#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdFieldMap%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdFieldMap", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 29, + "exported": true, + "identity": "MsdmdFieldMap#0", + "kind": "TypeAliasDeclaration", + "name": "MsdmdFieldMap", + "parameters": [], + "qualified_name": "MsdmdFieldMap", + "returns": "Record<string, string>", + "start_line": 29 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 29, + "start_line": 29 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdFieldMap%230", + "identity": "MsdmdFieldMap#0", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGap%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdGap", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 66, + "exported": true, + "identity": "MsdmdGap#0", + "kind": "TypeAliasDeclaration", + "name": "MsdmdGap", + "parameters": [], + "qualified_name": "MsdmdGap", + "returns": "MsdmdGapV1", + "start_line": 66 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 66, + "start_line": 66 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGap%230", + "identity": "MsdmdGap#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV1%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdGapV1", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 43, + "exported": true, + "identity": "MsdmdGapV1#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdGapV1", + "parameters": [], + "qualified_name": "MsdmdGapV1", + "returns": null, + "start_line": 39 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 43, + "start_line": 39 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV1%230", + "identity": "MsdmdGapV1#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV1.file%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdGapV1.file", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 40, + "exported": false, + "identity": "MsdmdGapV1.file#0", + "kind": "PropertySignature", + "name": "file", + "parameters": [], + "qualified_name": "MsdmdGapV1.file", + "returns": "string", + "start_line": 40 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 40, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV1.file%230", + "identity": "MsdmdGapV1.file#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV1.missing%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdGapV1.missing", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 41, + "exported": false, + "identity": "MsdmdGapV1.missing#0", + "kind": "PropertySignature", + "name": "missing", + "parameters": [], + "qualified_name": "MsdmdGapV1.missing", + "returns": "string[]", + "start_line": 41 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 41, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV1.missing%230", + "identity": "MsdmdGapV1.missing#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV1.reason%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdGapV1.reason", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 42, + "exported": false, + "identity": "MsdmdGapV1.reason#0", + "kind": "PropertySignature", + "name": "reason", + "parameters": [], + "qualified_name": "MsdmdGapV1.reason", + "returns": "string", + "start_line": 42 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 42, + "start_line": 42 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV1.reason%230", + "identity": "MsdmdGapV1.reason#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV2%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdGapV2", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 197, + "exported": true, + "identity": "MsdmdGapV2#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdGapV2", + "parameters": [], + "qualified_name": "MsdmdGapV2", + "returns": null, + "start_line": 193 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 197, + "start_line": 193 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV2%230", + "identity": "MsdmdGapV2#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV2.file%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdGapV2.file", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 194, + "exported": false, + "identity": "MsdmdGapV2.file#0", + "kind": "PropertySignature", + "name": "file", + "parameters": [], + "qualified_name": "MsdmdGapV2.file", + "returns": "string", + "start_line": 194 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 194, + "start_line": 194 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV2.file%230", + "identity": "MsdmdGapV2.file#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV2.kind%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdGapV2.kind", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 196, + "exported": false, + "identity": "MsdmdGapV2.kind#0", + "kind": "PropertySignature", + "name": "kind", + "parameters": [], + "qualified_name": "MsdmdGapV2.kind", + "returns": "\"block-adoption\"", + "start_line": 196 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 196, + "start_line": 196 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV2.kind%230", + "identity": "MsdmdGapV2.kind#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV2.missing%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdGapV2.missing", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 195, + "exported": false, + "identity": "MsdmdGapV2.missing#0", + "kind": "PropertySignature", + "name": "missing", + "parameters": [], + "qualified_name": "MsdmdGapV2.missing", + "returns": "MsdmdBlockName[]", + "start_line": 195 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 195, + "start_line": 195 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdGapV2.missing%230", + "identity": "MsdmdGapV2.missing#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdNativeFact", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 126, + "exported": true, + "identity": "MsdmdNativeFact#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdNativeFact", + "parameters": [], + "qualified_name": "MsdmdNativeFact", + "returns": null, + "start_line": 93 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 126, + "start_line": 93 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact%230", + "identity": "MsdmdNativeFact#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.address%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.address", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 94, + "exported": false, + "identity": "MsdmdNativeFact.address#0", + "kind": "PropertySignature", + "name": "address", + "parameters": [], + "qualified_name": "MsdmdNativeFact.address", + "returns": "string", + "start_line": 94 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 94, + "start_line": 94 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.address%230", + "identity": "MsdmdNativeFact.address#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.convention%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.convention", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 107, + "exported": false, + "identity": "MsdmdNativeFact.convention#0", + "kind": "PropertySignature", + "name": "convention", + "parameters": [], + "qualified_name": "MsdmdNativeFact.convention", + "returns": "{\n namespace: string;\n version: string;\n dialect: string;\n }", + "start_line": 103 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 107, + "start_line": 103 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.convention%230", + "identity": "MsdmdNativeFact.convention#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.convention.dialect%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.convention.dialect", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 106, + "exported": false, + "identity": "MsdmdNativeFact.convention.dialect#0", + "kind": "PropertySignature", + "name": "dialect", + "parameters": [], + "qualified_name": "MsdmdNativeFact.convention.dialect", + "returns": "string", + "start_line": 106 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 106, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.convention.dialect%230", + "identity": "MsdmdNativeFact.convention.dialect#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.convention.namespace%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.convention.namespace", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 104, + "exported": false, + "identity": "MsdmdNativeFact.convention.namespace#0", + "kind": "PropertySignature", + "name": "namespace", + "parameters": [], + "qualified_name": "MsdmdNativeFact.convention.namespace", + "returns": "string", + "start_line": 104 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 104, + "start_line": 104 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.convention.namespace%230", + "identity": "MsdmdNativeFact.convention.namespace#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.convention.version%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.convention.version", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 105, + "exported": false, + "identity": "MsdmdNativeFact.convention.version#0", + "kind": "PropertySignature", + "name": "version", + "parameters": [], + "qualified_name": "MsdmdNativeFact.convention.version", + "returns": "string", + "start_line": 105 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 105, + "start_line": 105 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.convention.version%230", + "identity": "MsdmdNativeFact.convention.version#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.extraction", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 119, + "exported": false, + "identity": "MsdmdNativeFact.extraction#0", + "kind": "PropertySignature", + "name": "extraction", + "parameters": [], + "qualified_name": "MsdmdNativeFact.extraction", + "returns": "{\n reader_id: string;\n reader_version: string;\n support: \"implemented-and-tested\" | \"partial\" | \"specified-only\" | \"unsupported\";\n configuration_sha256: string;\n implementation_sha256?: string;\n }", + "start_line": 113 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 119, + "start_line": 113 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction%230", + "identity": "MsdmdNativeFact.extraction#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction.configuration_sha256%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.extraction.configuration_sha256", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 117, + "exported": false, + "identity": "MsdmdNativeFact.extraction.configuration_sha256#0", + "kind": "PropertySignature", + "name": "configuration_sha256", + "parameters": [], + "qualified_name": "MsdmdNativeFact.extraction.configuration_sha256", + "returns": "string", + "start_line": 117 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 117, + "start_line": 117 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction.configuration_sha256%230", + "identity": "MsdmdNativeFact.extraction.configuration_sha256#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction.implementation_sha256%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.extraction.implementation_sha256", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 118, + "exported": false, + "identity": "MsdmdNativeFact.extraction.implementation_sha256#0", + "kind": "PropertySignature", + "name": "implementation_sha256", + "parameters": [], + "qualified_name": "MsdmdNativeFact.extraction.implementation_sha256", + "returns": "string", + "start_line": 118 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 118, + "start_line": 118 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction.implementation_sha256%230", + "identity": "MsdmdNativeFact.extraction.implementation_sha256#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction.reader_id%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.extraction.reader_id", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 114, + "exported": false, + "identity": "MsdmdNativeFact.extraction.reader_id#0", + "kind": "PropertySignature", + "name": "reader_id", + "parameters": [], + "qualified_name": "MsdmdNativeFact.extraction.reader_id", + "returns": "string", + "start_line": 114 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 114, + "start_line": 114 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction.reader_id%230", + "identity": "MsdmdNativeFact.extraction.reader_id#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction.reader_version%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.extraction.reader_version", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 115, + "exported": false, + "identity": "MsdmdNativeFact.extraction.reader_version#0", + "kind": "PropertySignature", + "name": "reader_version", + "parameters": [], + "qualified_name": "MsdmdNativeFact.extraction.reader_version", + "returns": "string", + "start_line": 115 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 115, + "start_line": 115 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction.reader_version%230", + "identity": "MsdmdNativeFact.extraction.reader_version#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction.support%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.extraction.support", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 116, + "exported": false, + "identity": "MsdmdNativeFact.extraction.support#0", + "kind": "PropertySignature", + "name": "support", + "parameters": [], + "qualified_name": "MsdmdNativeFact.extraction.support", + "returns": "\"implemented-and-tested\" | \"partial\" | \"specified-only\" | \"unsupported\"", + "start_line": 116 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 116, + "start_line": 116 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.extraction.support%230", + "identity": "MsdmdNativeFact.extraction.support#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.kind%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.kind", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 96, + "exported": false, + "identity": "MsdmdNativeFact.kind#0", + "kind": "PropertySignature", + "name": "kind", + "parameters": [], + "qualified_name": "MsdmdNativeFact.kind", + "returns": "string", + "start_line": 96 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 96, + "start_line": 96 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.kind%230", + "identity": "MsdmdNativeFact.kind#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.native%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.native", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 111, + "exported": false, + "identity": "MsdmdNativeFact.native#0", + "kind": "PropertySignature", + "name": "native", + "parameters": [], + "qualified_name": "MsdmdNativeFact.native", + "returns": "{\n id: string | null;\n value: JsonValue;\n }", + "start_line": 108 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 111, + "start_line": 108 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.native%230", + "identity": "MsdmdNativeFact.native#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.native.id%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.native.id", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 109, + "exported": false, + "identity": "MsdmdNativeFact.native.id#0", + "kind": "PropertySignature", + "name": "id", + "parameters": [], + "qualified_name": "MsdmdNativeFact.native.id", + "returns": "string | null", + "start_line": 109 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 109, + "start_line": 109 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.native.id%230", + "identity": "MsdmdNativeFact.native.id#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.native.value%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.native.value", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 110, + "exported": false, + "identity": "MsdmdNativeFact.native.value#0", + "kind": "PropertySignature", + "name": "value", + "parameters": [], + "qualified_name": "MsdmdNativeFact.native.value", + "returns": "JsonValue", + "start_line": 110 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 110, + "start_line": 110 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.native.value%230", + "identity": "MsdmdNativeFact.native.value#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.origin%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.origin", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 95, + "exported": false, + "identity": "MsdmdNativeFact.origin#0", + "kind": "PropertySignature", + "name": "origin", + "parameters": [], + "qualified_name": "MsdmdNativeFact.origin", + "returns": "\"native\"", + "start_line": 95 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 95, + "start_line": 95 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.origin%230", + "identity": "MsdmdNativeFact.origin#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.projection%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.projection", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 125, + "exported": false, + "identity": "MsdmdNativeFact.projection#0", + "kind": "PropertySignature", + "name": "projection", + "parameters": [], + "qualified_name": "MsdmdNativeFact.projection", + "returns": "{\n mapping_version: string;\n canonical_field?: string;\n relation?: string;\n loss: string;\n }", + "start_line": 120 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 125, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.projection%230", + "identity": "MsdmdNativeFact.projection#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.projection.canonical_field%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.projection.canonical_field", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 122, + "exported": false, + "identity": "MsdmdNativeFact.projection.canonical_field#0", + "kind": "PropertySignature", + "name": "canonical_field", + "parameters": [], + "qualified_name": "MsdmdNativeFact.projection.canonical_field", + "returns": "string", + "start_line": 122 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 122, + "start_line": 122 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.projection.canonical_field%230", + "identity": "MsdmdNativeFact.projection.canonical_field#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.projection.loss%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.projection.loss", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 124, + "exported": false, + "identity": "MsdmdNativeFact.projection.loss#0", + "kind": "PropertySignature", + "name": "loss", + "parameters": [], + "qualified_name": "MsdmdNativeFact.projection.loss", + "returns": "string", + "start_line": 124 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 124, + "start_line": 124 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.projection.loss%230", + "identity": "MsdmdNativeFact.projection.loss#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.projection.mapping_version%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.projection.mapping_version", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 121, + "exported": false, + "identity": "MsdmdNativeFact.projection.mapping_version#0", + "kind": "PropertySignature", + "name": "mapping_version", + "parameters": [], + "qualified_name": "MsdmdNativeFact.projection.mapping_version", + "returns": "string", + "start_line": 121 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 121, + "start_line": 121 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.projection.mapping_version%230", + "identity": "MsdmdNativeFact.projection.mapping_version#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.projection.relation%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.projection.relation", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 123, + "exported": false, + "identity": "MsdmdNativeFact.projection.relation#0", + "kind": "PropertySignature", + "name": "relation", + "parameters": [], + "qualified_name": "MsdmdNativeFact.projection.relation", + "returns": "string", + "start_line": 123 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 123, + "start_line": 123 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.projection.relation%230", + "identity": "MsdmdNativeFact.projection.relation#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.source%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.source", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 97, + "exported": false, + "identity": "MsdmdNativeFact.source#0", + "kind": "PropertySignature", + "name": "source", + "parameters": [], + "qualified_name": "MsdmdNativeFact.source", + "returns": "MsdmdSourceReference", + "start_line": 97 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 97, + "start_line": 97 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.source%230", + "identity": "MsdmdNativeFact.source#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.standing%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.standing", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 112, + "exported": false, + "identity": "MsdmdNativeFact.standing#0", + "kind": "PropertySignature", + "name": "standing", + "parameters": [], + "qualified_name": "MsdmdNativeFact.standing", + "returns": "\"declared\" | \"syntactically-observed\" | \"derived\" | \"reported-evidence\"", + "start_line": 112 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 112, + "start_line": 112 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.standing%230", + "identity": "MsdmdNativeFact.standing#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.subject%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.subject", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 102, + "exported": false, + "identity": "MsdmdNativeFact.subject#0", + "kind": "PropertySignature", + "name": "subject", + "parameters": [], + "qualified_name": "MsdmdNativeFact.subject", + "returns": "{\n address: string;\n scope: string;\n identity: string;\n }", + "start_line": 98 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 102, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.subject%230", + "identity": "MsdmdNativeFact.subject#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.subject.address%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.subject.address", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 99, + "exported": false, + "identity": "MsdmdNativeFact.subject.address#0", + "kind": "PropertySignature", + "name": "address", + "parameters": [], + "qualified_name": "MsdmdNativeFact.subject.address", + "returns": "string", + "start_line": 99 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 99, + "start_line": 99 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.subject.address%230", + "identity": "MsdmdNativeFact.subject.address#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.subject.identity%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.subject.identity", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 101, + "exported": false, + "identity": "MsdmdNativeFact.subject.identity#0", + "kind": "PropertySignature", + "name": "identity", + "parameters": [], + "qualified_name": "MsdmdNativeFact.subject.identity", + "returns": "string", + "start_line": 101 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 101, + "start_line": 101 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.subject.identity%230", + "identity": "MsdmdNativeFact.subject.identity#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.subject.scope%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdNativeFact.subject.scope", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 100, + "exported": false, + "identity": "MsdmdNativeFact.subject.scope#0", + "kind": "PropertySignature", + "name": "scope", + "parameters": [], + "qualified_name": "MsdmdNativeFact.subject.scope", + "returns": "string", + "start_line": 100 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 100, + "start_line": 100 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdNativeFact.subject.scope%230", + "identity": "MsdmdNativeFact.subject.scope#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdReaderManifest", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 143, + "exported": true, + "identity": "MsdmdReaderManifest#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdReaderManifest", + "parameters": [], + "qualified_name": "MsdmdReaderManifest", + "returns": null, + "start_line": 128 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 143, + "start_line": 128 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest%230", + "identity": "MsdmdReaderManifest#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.convention%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.convention", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 133, + "exported": false, + "identity": "MsdmdReaderManifest.convention#0", + "kind": "PropertySignature", + "name": "convention", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.convention", + "returns": "string", + "start_line": 133 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 133, + "start_line": 133 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.convention%230", + "identity": "MsdmdReaderManifest.convention#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.dependencies%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.dependencies", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 132, + "exported": false, + "identity": "MsdmdReaderManifest.dependencies#0", + "kind": "PropertySignature", + "name": "dependencies", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.dependencies", + "returns": "string[]", + "start_line": 132 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 132, + "start_line": 132 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.dependencies%230", + "identity": "MsdmdReaderManifest.dependencies#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.detection%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.detection", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 137, + "exported": false, + "identity": "MsdmdReaderManifest.detection#0", + "kind": "PropertySignature", + "name": "detection", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.detection", + "returns": "string[]", + "start_line": 137 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 137, + "start_line": 137 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.detection%230", + "identity": "MsdmdReaderManifest.detection#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.entry_point%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.entry_point", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 131, + "exported": false, + "identity": "MsdmdReaderManifest.entry_point#0", + "kind": "PropertySignature", + "name": "entry_point", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.entry_point", + "returns": "string", + "start_line": 131 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 131, + "start_line": 131 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.entry_point%230", + "identity": "MsdmdReaderManifest.entry_point#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.execution_policy%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.execution_policy", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 140, + "exported": false, + "identity": "MsdmdReaderManifest.execution_policy#0", + "kind": "PropertySignature", + "name": "execution_policy", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.execution_policy", + "returns": "string", + "start_line": 140 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 140, + "start_line": 140 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.execution_policy%230", + "identity": "MsdmdReaderManifest.execution_policy#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.feature_subset%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.feature_subset", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 136, + "exported": false, + "identity": "MsdmdReaderManifest.feature_subset#0", + "kind": "PropertySignature", + "name": "feature_subset", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.feature_subset", + "returns": "string[]", + "start_line": 136 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 136, + "start_line": 136 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.feature_subset%230", + "identity": "MsdmdReaderManifest.feature_subset#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.known_limitations%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.known_limitations", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 142, + "exported": false, + "identity": "MsdmdReaderManifest.known_limitations#0", + "kind": "PropertySignature", + "name": "known_limitations", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.known_limitations", + "returns": "string[]", + "start_line": 142 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 142, + "start_line": 142 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.known_limitations%230", + "identity": "MsdmdReaderManifest.known_limitations#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.reader_id%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.reader_id", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 129, + "exported": false, + "identity": "MsdmdReaderManifest.reader_id#0", + "kind": "PropertySignature", + "name": "reader_id", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.reader_id", + "returns": "string", + "start_line": 129 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 129, + "start_line": 129 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.reader_id%230", + "identity": "MsdmdReaderManifest.reader_id#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.scope_attachment%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.scope_attachment", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 138, + "exported": false, + "identity": "MsdmdReaderManifest.scope_attachment#0", + "kind": "PropertySignature", + "name": "scope_attachment", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.scope_attachment", + "returns": "string", + "start_line": 138 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 138, + "start_line": 138 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.scope_attachment%230", + "identity": "MsdmdReaderManifest.scope_attachment#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.specification%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.specification", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 134, + "exported": false, + "identity": "MsdmdReaderManifest.specification#0", + "kind": "PropertySignature", + "name": "specification", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.specification", + "returns": "string", + "start_line": 134 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 134, + "start_line": 134 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.specification%230", + "identity": "MsdmdReaderManifest.specification#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.support%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.support", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 141, + "exported": false, + "identity": "MsdmdReaderManifest.support#0", + "kind": "PropertySignature", + "name": "support", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.support", + "returns": "\"implemented-and-tested\" | \"partial\" | \"specified-only\" | \"unsupported\"", + "start_line": 141 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 141, + "start_line": 141 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.support%230", + "identity": "MsdmdReaderManifest.support#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.supported_versions%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.supported_versions", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 135, + "exported": false, + "identity": "MsdmdReaderManifest.supported_versions#0", + "kind": "PropertySignature", + "name": "supported_versions", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.supported_versions", + "returns": "string[]", + "start_line": 135 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 135, + "start_line": 135 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.supported_versions%230", + "identity": "MsdmdReaderManifest.supported_versions#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.unknown_field_policy%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.unknown_field_policy", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 139, + "exported": false, + "identity": "MsdmdReaderManifest.unknown_field_policy#0", + "kind": "PropertySignature", + "name": "unknown_field_policy", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.unknown_field_policy", + "returns": "string", + "start_line": 139 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 139, + "start_line": 139 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.unknown_field_policy%230", + "identity": "MsdmdReaderManifest.unknown_field_policy#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.version%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderManifest.version", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 130, + "exported": false, + "identity": "MsdmdReaderManifest.version#0", + "kind": "PropertySignature", + "name": "version", + "parameters": [], + "qualified_name": "MsdmdReaderManifest.version", + "returns": "string", + "start_line": 130 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 130, + "start_line": 130 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderManifest.version%230", + "identity": "MsdmdReaderManifest.version#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdReaderRun", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 152, + "exported": true, + "identity": "MsdmdReaderRun#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdReaderRun", + "parameters": [], + "qualified_name": "MsdmdReaderRun", + "returns": null, + "start_line": 145 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 152, + "start_line": 145 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun%230", + "identity": "MsdmdReaderRun#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.facts_emitted%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderRun.facts_emitted", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 151, + "exported": false, + "identity": "MsdmdReaderRun.facts_emitted#0", + "kind": "PropertySignature", + "name": "facts_emitted", + "parameters": [], + "qualified_name": "MsdmdReaderRun.facts_emitted", + "returns": "number", + "start_line": 151 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 151, + "start_line": 151 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.facts_emitted%230", + "identity": "MsdmdReaderRun.facts_emitted#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.files_matched%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderRun.files_matched", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 150, + "exported": false, + "identity": "MsdmdReaderRun.files_matched#0", + "kind": "PropertySignature", + "name": "files_matched", + "parameters": [], + "qualified_name": "MsdmdReaderRun.files_matched", + "returns": "number", + "start_line": 150 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 150, + "start_line": 150 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.files_matched%230", + "identity": "MsdmdReaderRun.files_matched#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.reader_id%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderRun.reader_id", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 146, + "exported": false, + "identity": "MsdmdReaderRun.reader_id#0", + "kind": "PropertySignature", + "name": "reader_id", + "parameters": [], + "qualified_name": "MsdmdReaderRun.reader_id", + "returns": "string", + "start_line": 146 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 146, + "start_line": 146 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.reader_id%230", + "identity": "MsdmdReaderRun.reader_id#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.reader_version%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderRun.reader_version", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 147, + "exported": false, + "identity": "MsdmdReaderRun.reader_version#0", + "kind": "PropertySignature", + "name": "reader_version", + "parameters": [], + "qualified_name": "MsdmdReaderRun.reader_version", + "returns": "string", + "start_line": 147 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 147, + "start_line": 147 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.reader_version%230", + "identity": "MsdmdReaderRun.reader_version#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.status%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderRun.status", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 149, + "exported": false, + "identity": "MsdmdReaderRun.status#0", + "kind": "PropertySignature", + "name": "status", + "parameters": [], + "qualified_name": "MsdmdReaderRun.status", + "returns": "\"applied\" | \"not-applicable\"", + "start_line": 149 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 149, + "start_line": 149 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.status%230", + "identity": "MsdmdReaderRun.status#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.support%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdReaderRun.support", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 148, + "exported": false, + "identity": "MsdmdReaderRun.support#0", + "kind": "PropertySignature", + "name": "support", + "parameters": [], + "qualified_name": "MsdmdReaderRun.support", + "returns": "MsdmdReaderManifest[\"support\"]", + "start_line": 148 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 148, + "start_line": 148 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdReaderRun.support%230", + "identity": "MsdmdReaderRun.support#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdSourceLocation", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 72, + "exported": true, + "identity": "MsdmdSourceLocation#0", + "kind": "TypeAliasDeclaration", + "name": "MsdmdSourceLocation", + "parameters": [], + "qualified_name": "MsdmdSourceLocation", + "returns": "| { pointer: string }\n | { start_line: number; end_line: number; span?: JsonValue; start_byte?: number; end_byte?: number }", + "start_line": 70 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 72, + "start_line": 70 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation%230", + "identity": "MsdmdSourceLocation#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.end_byte%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdSourceLocation.end_byte", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 72, + "exported": false, + "identity": "MsdmdSourceLocation.end_byte#0", + "kind": "PropertySignature", + "name": "end_byte", + "parameters": [], + "qualified_name": "MsdmdSourceLocation.end_byte", + "returns": "number", + "start_line": 72 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 72, + "start_line": 72 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.end_byte%230", + "identity": "MsdmdSourceLocation.end_byte#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.end_line%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdSourceLocation.end_line", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 72, + "exported": false, + "identity": "MsdmdSourceLocation.end_line#0", + "kind": "PropertySignature", + "name": "end_line", + "parameters": [], + "qualified_name": "MsdmdSourceLocation.end_line", + "returns": "number", + "start_line": 72 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 72, + "start_line": 72 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.end_line%230", + "identity": "MsdmdSourceLocation.end_line#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.pointer%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdSourceLocation.pointer", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 71, + "exported": false, + "identity": "MsdmdSourceLocation.pointer#0", + "kind": "PropertySignature", + "name": "pointer", + "parameters": [], + "qualified_name": "MsdmdSourceLocation.pointer", + "returns": "string", + "start_line": 71 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 71, + "start_line": 71 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.pointer%230", + "identity": "MsdmdSourceLocation.pointer#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.span%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdSourceLocation.span", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 72, + "exported": false, + "identity": "MsdmdSourceLocation.span#0", + "kind": "PropertySignature", + "name": "span", + "parameters": [], + "qualified_name": "MsdmdSourceLocation.span", + "returns": "JsonValue", + "start_line": 72 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 72, + "start_line": 72 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.span%230", + "identity": "MsdmdSourceLocation.span#0", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.start_byte%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdSourceLocation.start_byte", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 72, + "exported": false, + "identity": "MsdmdSourceLocation.start_byte#0", + "kind": "PropertySignature", + "name": "start_byte", + "parameters": [], + "qualified_name": "MsdmdSourceLocation.start_byte", + "returns": "number", + "start_line": 72 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 72, + "start_line": 72 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.start_byte%230", + "identity": "MsdmdSourceLocation.start_byte#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.start_line%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdSourceLocation.start_line", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 72, + "exported": false, + "identity": "MsdmdSourceLocation.start_line#0", + "kind": "PropertySignature", + "name": "start_line", + "parameters": [], + "qualified_name": "MsdmdSourceLocation.start_line", + "returns": "number", + "start_line": 72 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 72, + "start_line": 72 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceLocation.start_line%230", + "identity": "MsdmdSourceLocation.start_line#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "MsdmdSourceReference", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 80, + "exported": true, + "identity": "MsdmdSourceReference#0", + "kind": "InterfaceDeclaration", + "name": "MsdmdSourceReference", + "parameters": [], + "qualified_name": "MsdmdSourceReference", + "returns": null, + "start_line": 74 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 80, + "start_line": 74 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference%230", + "identity": "MsdmdSourceReference#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference.content_sha256%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdSourceReference.content_sha256", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 78, + "exported": false, + "identity": "MsdmdSourceReference.content_sha256#0", + "kind": "PropertySignature", + "name": "content_sha256", + "parameters": [], + "qualified_name": "MsdmdSourceReference.content_sha256", + "returns": "string", + "start_line": 78 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 78, + "start_line": 78 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference.content_sha256%230", + "identity": "MsdmdSourceReference.content_sha256#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference.file%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdSourceReference.file", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 77, + "exported": false, + "identity": "MsdmdSourceReference.file#0", + "kind": "PropertySignature", + "name": "file", + "parameters": [], + "qualified_name": "MsdmdSourceReference.file", + "returns": "string", + "start_line": 77 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 77, + "start_line": 77 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference.file%230", + "identity": "MsdmdSourceReference.file#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference.location%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdSourceReference.location", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 79, + "exported": false, + "identity": "MsdmdSourceReference.location#0", + "kind": "PropertySignature", + "name": "location", + "parameters": [], + "qualified_name": "MsdmdSourceReference.location", + "returns": "MsdmdSourceLocation", + "start_line": 79 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 79, + "start_line": 79 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference.location%230", + "identity": "MsdmdSourceReference.location#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference.repository%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdSourceReference.repository", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 75, + "exported": false, + "identity": "MsdmdSourceReference.repository#0", + "kind": "PropertySignature", + "name": "repository", + "parameters": [], + "qualified_name": "MsdmdSourceReference.repository", + "returns": "string", + "start_line": 75 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 75, + "start_line": 75 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference.repository%230", + "identity": "MsdmdSourceReference.repository#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference.revision%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "MsdmdSourceReference.revision", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 76, + "exported": false, + "identity": "MsdmdSourceReference.revision#0", + "kind": "PropertySignature", + "name": "revision", + "parameters": [], + "qualified_name": "MsdmdSourceReference.revision", + "returns": "string", + "start_line": 76 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 76, + "start_line": 76 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/MsdmdSourceReference.revision%230", + "identity": "MsdmdSourceReference.revision#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/defineMsdmdCollection%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "defineMsdmdCollection", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 246, + "exported": true, + "identity": "defineMsdmdCollection#0", + "kind": "FunctionDeclaration", + "name": "defineMsdmdCollection", + "parameters": [ + { + "default": null, + "name": "collection", + "optional": false, + "rest": false, + "type": "MsdmdCollectionV1" + } + ], + "qualified_name": "defineMsdmdCollection", + "returns": "MsdmdCollectionV1", + "start_line": 244 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 246, + "start_line": 244 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/defineMsdmdCollection%230", + "identity": "defineMsdmdCollection#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/defineMsdmdCollection%230/fact/documentation/4", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.documentation-comment", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "description": "Explicit compatibility helper for block-only schema-1 collection points.", + "end_line": 243, + "identity": "defineMsdmdCollection#0", + "owner": "defineMsdmdCollection", + "start_line": 243, + "tags": [], + "text": "/** Explicit compatibility helper for block-only schema-1 collection points. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 243, + "start_line": 243 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/defineMsdmdCollection%230", + "identity": "defineMsdmdCollection#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/defineMsdmdCollectionV2%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "defineMsdmdCollectionV2", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 251, + "exported": true, + "identity": "defineMsdmdCollectionV2#0", + "kind": "FunctionDeclaration", + "name": "defineMsdmdCollectionV2", + "parameters": [ + { + "default": null, + "name": "collection", + "optional": false, + "rest": false, + "type": "MsdmdCollectionV2" + } + ], + "qualified_name": "defineMsdmdCollectionV2", + "returns": "MsdmdCollectionV2", + "start_line": 249 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 251, + "start_line": 249 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/defineMsdmdCollectionV2%230", + "identity": "defineMsdmdCollectionV2#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/defineMsdmdCollectionV2%230/fact/documentation/5", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.documentation-comment", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "description": "Native-capable schema-2 helper. Consumers must opt into this exact version.", + "end_line": 248, + "identity": "defineMsdmdCollectionV2#0", + "owner": "defineMsdmdCollectionV2", + "start_line": 248, + "tags": [], + "text": "/** Native-capable schema-2 helper. Consumers must opt into this exact version. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 248, + "start_line": 248 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/defineMsdmdCollectionV2%230", + "identity": "defineMsdmdCollectionV2#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/mergeMsdmdFactChunks%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "mergeMsdmdFactChunks", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 255, + "exported": true, + "identity": "mergeMsdmdFactChunks#0", + "kind": "FunctionDeclaration", + "name": "mergeMsdmdFactChunks", + "parameters": [ + { + "default": null, + "name": "chunks", + "optional": false, + "rest": true, + "type": "MsdmdNativeFact[][]" + } + ], + "qualified_name": "mergeMsdmdFactChunks", + "returns": "MsdmdNativeFact[]", + "start_line": 253 + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 255, + "start_line": 253 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/mergeMsdmdFactChunks%230", + "identity": "mergeMsdmdFactChunks#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/mergeMsdmdFactChunks%230/fact/documentation/6", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.documentation-comment", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "description": "Keep large generated literals type-checkable without any/unknown casts.", + "end_line": 252, + "identity": "mergeMsdmdFactChunks#0", + "owner": "mergeMsdmdFactChunks", + "start_line": 252, + "tags": [], + "text": "/** Keep large generated literals type-checkable without any/unknown casts. */" + } + }, + "origin": "native", + "source": { + "content_sha256": "c3f319abe45e807dc750aa5cf99103ab340f8edebf3b3add55d475b1a7e55eba", + "file": "msdmd/collection.ts", + "location": { + "end_line": 252, + "start_line": 252 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/collection.ts#subject/symbol/mergeMsdmdFactChunks%230", + "identity": "mergeMsdmdFactChunks#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "78:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A189-189/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "78:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 189, + "start_line": 189 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "9:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A189-189/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "9:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 189, + "start_line": 189 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "151:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A189-189/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "151:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 189, + "start_line": 189 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=151:14 imports_exports=9:5 calls_definitions=78:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 73, + "column": 73, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "identity": "msdmd/formats.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=151:14 imports_exports=9:5 calls_definitions=78:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 189, + "span": { + "end": { + "byte": 8614, + "column": 73, + "line": 189 + }, + "start": { + "byte": 8541, + "column": 0, + "line": 189 + } + }, + "start_line": 189 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "identity": "msdmd/formats.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::<module>", + "description": "Usage: parse_json(bytes), parse_yaml(bytes), parse_xml(bytes). No includes,\nconstructors, network references or target code are executed. YAML uses PyYAML's\nsyntax parser with explicit YAML 1.2 core scalar resolution and typed scalar keys.\nRepeated keys, cyclic aliases, custom tags, merge keys and excessive expansion\nare errors, never silently flattened. XML supports UTF-8, without DTD/entities.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Bounded, non-executing parsers shared by the native metadata adapters.", + "text": "Bounded, non-executing parsers shared by the native metadata adapters.\n\nUsage: parse_json(bytes), parse_yaml(bytes), parse_xml(bytes). No includes,\nconstructors, network references or target code are executed. YAML uses PyYAML's\nsyntax parser with explicit YAML 1.2 core scalar resolution and typed scalar keys.\nRepeated keys, cyclic aliases, custom tags, merge keys and excessive expansion\nare errors, never silently flattened. XML supports UTF-8, without DTD/entities.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 9, + "span": { + "end": { + "byte": 551, + "column": 3, + "line": 9 + }, + "start": { + "byte": 74, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "identity": "msdmd/formats.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "identity": "msdmd/formats.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "identity": "msdmd/formats.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "decimal:Decimal:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "decimal", + "name": "Decimal" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "identity": "msdmd/formats.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "math:math:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "math", + "name": "math" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "identity": "msdmd/formats.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "identity": "msdmd/formats.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "xml.etree.ElementTree:xml.etree.ElementTree:5", + "value": { + "alias": "ET", + "kind": "import", + "level": 0, + "module": "xml.etree.ElementTree", + "name": "xml.etree.ElementTree" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "identity": "msdmd/formats.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "identity": "msdmd/formats.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "urllib.parse:urlsplit:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "urllib.parse", + "name": "urlsplit" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/module/msdmd%2Fformats.py", + "identity": "msdmd/formats.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/check_tree/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "check_tree", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:check_tree", + "decorators": [], + "kind": "function", + "name": "check_tree", + "parent_identity": null, + "qualified_name": "check_tree", + "signature": "def check_tree(value: Any, depth: int=0, budget: list[int] | None=None) -> Any" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 52, + "span": { + "end": { + "byte": 2003, + "column": 16, + "line": 52 + }, + "start": { + "byte": 1491, + "column": 0, + "line": 41 + } + }, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/check_tree", + "identity": "check_tree", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/is_json_schema_uri/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "is_json_schema_uri", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:is_json_schema_uri", + "decorators": [], + "kind": "function", + "name": "is_json_schema_uri", + "parent_identity": null, + "qualified_name": "is_json_schema_uri", + "signature": "def is_json_schema_uri(value: Any) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 34, + "span": { + "end": { + "byte": 1450, + "column": 86, + "line": 34 + }, + "start": { + "byte": 743, + "column": 0, + "line": 20 + } + }, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/is_json_schema_uri", + "identity": "is_json_schema_uri", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/is_json_schema_uri/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:is_json_schema_uri", + "description": "Usage: pass a native $schema value, without coercing its type. This\nrecognizes the owning namespace, not a supported draft or trusted URL.\nUserinfo, explicit ports, lookalike hosts and control characters are\noutside this recognition subset and remain unclassified source data.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Recognize the exact JSON Schema URI authority without fetching it.", + "text": "Recognize the exact JSON Schema URI authority without fetching it.\n\n Usage: pass a native $schema value, without coercing its type. This\n recognizes the owning namespace, not a supported draft or trusted URL.\n Userinfo, explicit ports, lookalike hosts and control characters are\n outside this recognition subset and remain unclassified source data.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 27, + "span": { + "end": { + "byte": 1162, + "column": 7, + "line": 27 + }, + "start": { + "byte": 791, + "column": 4, + "line": 21 + } + }, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/is_json_schema_uri", + "identity": "is_json_schema_uri", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_json.constant/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_json.constant", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_json.constant", + "decorators": [], + "kind": "function", + "name": "constant", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_json", + "qualified_name": "parse_json.constant", + "signature": "def constant(value: str) -> Any" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 65, + "span": { + "end": { + "byte": 2408, + "column": 50, + "line": 65 + }, + "start": { + "byte": 2325, + "column": 4, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_json.constant", + "identity": "parse_json.constant", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_json.integer/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_json.integer", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_json.integer", + "decorators": [], + "kind": "function", + "name": "integer", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_json", + "qualified_name": "parse_json.integer", + "signature": "def integer(value: str) -> Any" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 71, + "span": { + "end": { + "byte": 2611, + "column": 21, + "line": 71 + }, + "start": { + "byte": 2414, + "column": 4, + "line": 67 + } + }, + "start_line": 67 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_json.integer", + "identity": "parse_json.integer", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_json.number/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_json.number", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_json.number", + "decorators": [], + "kind": "function", + "name": "number", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_json", + "qualified_name": "parse_json.number", + "signature": "def number(value: str) -> Any" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 80, + "span": { + "end": { + "byte": 3007, + "column": 21, + "line": 80 + }, + "start": { + "byte": 2617, + "column": 4, + "line": 73 + } + }, + "start_line": 73 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_json.number", + "identity": "parse_json.number", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_json.pairs/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_json.pairs", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_json.pairs", + "decorators": [], + "kind": "function", + "name": "pairs", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_json", + "qualified_name": "parse_json.pairs", + "signature": "def pairs(items: list[tuple[str, Any]]) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 62, + "span": { + "end": { + "byte": 2319, + "column": 21, + "line": 62 + }, + "start": { + "byte": 2046, + "column": 4, + "line": 56 + } + }, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_json.pairs", + "identity": "parse_json.pairs", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_json/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_json", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_json", + "decorators": [], + "kind": "function", + "name": "parse_json", + "parent_identity": null, + "qualified_name": "parse_json", + "signature": "def parse_json(data: bytes) -> Any" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 82, + "span": { + "end": { + "byte": 3137, + "column": 128, + "line": 82 + }, + "start": { + "byte": 2006, + "column": 0, + "line": 55 + } + }, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_json", + "identity": "parse_json", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_xml/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_xml", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_xml", + "decorators": [], + "kind": "function", + "name": "parse_xml", + "parent_identity": null, + "qualified_name": "parse_xml", + "signature": "def parse_xml(data: bytes) -> ET.Element" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 188, + "span": { + "end": { + "byte": 8540, + "column": 15, + "line": 188 + }, + "start": { + "byte": 7829, + "column": 0, + "line": 173 + } + }, + "start_line": 173 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_xml", + "identity": "parse_xml", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml.CoreLoader/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "parse_yaml.CoreLoader", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::class:parse_yaml.CoreLoader", + "decorators": [], + "kind": "class", + "name": "CoreLoader", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_yaml", + "qualified_name": "parse_yaml.CoreLoader", + "signature": "class CoreLoader(yaml.BaseLoader)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 89, + "span": { + "end": { + "byte": 3341, + "column": 42, + "line": 89 + }, + "start": { + "byte": 3264, + "column": 4, + "line": 88 + } + }, + "start_line": 88 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml.CoreLoader", + "identity": "parse_yaml.CoreLoader", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml.scalar/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_yaml.scalar", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_yaml.scalar", + "decorators": [], + "kind": "function", + "name": "scalar", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_yaml", + "qualified_name": "parse_yaml.scalar", + "signature": "def scalar(text: str, tag: str) -> Any" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 124, + "span": { + "end": { + "byte": 5514, + "column": 65, + "line": 124 + }, + "start": { + "byte": 4082, + "column": 4, + "line": 98 + } + }, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml.scalar", + "identity": "parse_yaml.scalar", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml.visit/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_yaml.visit", + "metadata_kind": "comment", + "text": "JSON object keys cannot encode typed YAML keys without loss." + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 164, + "span": { + "end": { + "byte": 7630, + "column": 78, + "line": 164 + }, + "start": { + "byte": 7568, + "column": 16, + "line": 164 + } + }, + "start_line": 164 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml.visit", + "identity": "parse_yaml.visit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml.visit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_yaml.visit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_yaml.visit", + "decorators": [], + "kind": "function", + "name": "visit", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_yaml", + "qualified_name": "parse_yaml.visit", + "signature": "def visit(item: Any, depth: int=0) -> Any" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 168, + "span": { + "end": { + "byte": 7802, + "column": 35, + "line": 168 + }, + "start": { + "byte": 5520, + "column": 4, + "line": 126 + } + }, + "start_line": 126 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml.visit", + "identity": "parse_yaml.visit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_yaml", + "metadata_kind": "comment", + "text": "Optional reader dependency; missing installation is diagnostic." + } + }, + "origin": "native", + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 86, + "span": { + "end": { + "byte": 3258, + "column": 82, + "line": 86 + }, + "start": { + "byte": 3193, + "column": 17, + "line": 86 + } + }, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml", + "identity": "parse_yaml", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_yaml", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/formats.py::function:parse_yaml", + "decorators": [], + "kind": "function", + "name": "parse_yaml", + "parent_identity": null, + "qualified_name": "parse_yaml", + "signature": "def parse_yaml(data: bytes) -> Any" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 170, + "span": { + "end": { + "byte": 7826, + "column": 22, + "line": 170 + }, + "start": { + "byte": 3140, + "column": 0, + "line": 85 + } + }, + "start_line": 85 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml", + "identity": "parse_yaml", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "yaml:yaml:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "yaml", + "name": "yaml" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "02f90c329c26d4a15b95103c1659483a31038b94ba5f4d0d2b9f8181a62d575d", + "file": "msdmd/formats.py", + "location": { + "end_line": 86, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/formats.py#subject/symbol/parse_yaml", + "identity": "parse_yaml", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "41:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A136-136/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "41:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 136, + "start_line": 136 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "8:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A136-136/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "8:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 136, + "start_line": 136 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "116:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A136-136/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "116:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 136, + "start_line": 136 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=116:9 imports_exports=8:1 calls_definitions=41:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 71, + "column": 71, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "identity": "msdmd/grammar_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=116:9 imports_exports=8:1 calls_definitions=41:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 136, + "span": { + "end": { + "byte": 8031, + "column": 71, + "line": 136 + }, + "start": { + "byte": 7960, + "column": 0, + "line": 136 + } + }, + "start_line": 136 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "identity": "msdmd/grammar_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::<module>", + "description": "Usage: read_grammar(path, supplied_bytes, context) through msdmd.collect.\nNo build, macro expansion, annotation processing or target import occurs. .h\nrequires explicit language selection and is reported ambiguous. Documentation\nretains raw comments and repeated tags; it does not run rustdoc or Doxygen.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Source metadata from pinned Rust, Java, C and C++ grammars.", + "text": "Source metadata from pinned Rust, Java, C and C++ grammars.\n\nUsage: read_grammar(path, supplied_bytes, context) through msdmd.collect.\nNo build, macro expansion, annotation processing or target import occurs. .h\nrequires explicit language selection and is reported ambiguous. Documentation\nretains raw comments and repeated tags; it does not run rustdoc or Doxygen.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 8, + "span": { + "end": { + "byte": 444, + "column": 3, + "line": 8 + }, + "start": { + "byte": 72, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "identity": "msdmd/grammar_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "identity": "msdmd/grammar_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "identity": "msdmd/grammar_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "importlib:importlib:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "importlib", + "name": "importlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "identity": "msdmd/grammar_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "identity": "msdmd/grammar_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "identity": "msdmd/grammar_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/module/msdmd%2Fgrammar_code.py", + "identity": "msdmd/grammar_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar.emit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_grammar.emit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::function:read_grammar.emit", + "decorators": [], + "kind": "function", + "name": "emit", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::function:read_grammar", + "qualified_name": "read_grammar.emit", + "signature": "def emit(node: Any, kind: str, identity: str, value: Any, *, scope: str='symbol', convention: str | None=None) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 79, + "span": { + "end": { + "byte": 4058, + "column": 19, + "line": 79 + }, + "start": { + "byte": 3341, + "column": 4, + "line": 69 + } + }, + "start_line": 69 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar.emit", + "identity": "read_grammar.emit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar.name_of/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_grammar.name_of", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::function:read_grammar.name_of", + "decorators": [], + "kind": "function", + "name": "name_of", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::function:read_grammar", + "qualified_name": "read_grammar.name_of", + "signature": "def name_of(node: Any) -> str | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 67, + "span": { + "end": { + "byte": 3335, + "column": 55, + "line": 67 + }, + "start": { + "byte": 2859, + "column": 4, + "line": 59 + } + }, + "start_line": 59 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar.name_of", + "identity": "read_grammar.name_of", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar.text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_grammar.text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::function:read_grammar.text", + "decorators": [], + "kind": "function", + "name": "text", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::function:read_grammar", + "qualified_name": "read_grammar.text", + "signature": "def text(node: Any) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 57, + "span": { + "end": { + "byte": 2853, + "column": 66, + "line": 57 + }, + "start": { + "byte": 2759, + "column": 4, + "line": 56 + } + }, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar.text", + "identity": "read_grammar.text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::function:read_grammar", + "metadata_kind": "comment", + "text": "Only hard-coded installed grammar modules are loaded, never target modules." + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 37, + "span": { + "end": { + "byte": 1888, + "column": 81, + "line": 37 + }, + "start": { + "byte": 1811, + "column": 4, + "line": 37 + } + }, + "start_line": 37 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "identity": "read_grammar", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::function:read_grammar", + "metadata_kind": "comment", + "text": "Rust impl blocks have no named declaration; retain their type context." + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 86, + "span": { + "end": { + "byte": 4468, + "column": 84, + "line": 86 + }, + "start": { + "byte": 4396, + "column": 12, + "line": 86 + } + }, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "identity": "read_grammar", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::function:read_grammar", + "metadata_kind": "comment", + "text": "Only comments/attributes can bridge leading documentation." + } + }, + "origin": "native", + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 122, + "span": { + "end": { + "byte": 6890, + "column": 76, + "line": 122 + }, + "start": { + "byte": 6830, + "column": 16, + "line": 122 + } + }, + "start_line": 122 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "identity": "read_grammar", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_grammar", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/grammar_code.py::function:read_grammar", + "decorators": [], + "kind": "function", + "name": "read_grammar", + "parent_identity": null, + "qualified_name": "read_grammar", + "signature": "def read_grammar(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 7959, + "column": 33, + "line": 135 + }, + "start": { + "byte": 1298, + "column": 0, + "line": 29 + } + }, + "start_line": 29 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "identity": "read_grammar", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tree_sitter:Language:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tree_sitter", + "name": "Language" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 30, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "identity": "read_grammar", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tree_sitter:Parser:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tree_sitter", + "name": "Parser" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 30, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "identity": "read_grammar", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_fact:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_fact" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 31, + "start_line": 31 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "identity": "read_grammar", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_diagnostic:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_diagnostic" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2bd197f267c5aa5d94c60e54146d262f08aa0951a372a3ca84f02f476063cbf3", + "file": "msdmd/grammar_code.py", + "location": { + "end_line": 31, + "start_line": 31 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/grammar_code.py#subject/symbol/read_grammar", + "identity": "read_grammar", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2F%24defs%2Fmetadata%2Fproperties%2Fsource_span%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/span" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/$defs/metadata/properties/source_span/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2F%24defs%2Fmodule%2Fproperties%2Ffreshness_key_sha256%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/sha256" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/$defs/module/properties/freshness_key_sha256/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2F%24defs%2Fmodule%2Fproperties%2Freader_manifest_sha256%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/sha256" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/$defs/module/properties/reader_manifest_sha256/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2F%24defs%2Fmodule%2Fproperties%2Freader_sha256%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/sha256" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/$defs/module/properties/reader_sha256/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2F%24defs%2Fmodule%2Fproperties%2Fschema_sha256%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/sha256" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/$defs/module/properties/schema_sha256/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2F%24defs%2Fmodule%2Fproperties%2Fsource_sha256%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/sha256" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/$defs/module/properties/source_sha256/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2F%24defs%2Fspan%2Fproperties%2Fend%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/position" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/$defs/span/properties/end/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2F%24defs%2Fspan%2Fproperties%2Fstart%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/position" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/$defs/span/properties/start/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2F%24defs%2Fsymbol%2Fproperties%2Fsignature_sha256%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/sha256" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/$defs/symbol/properties/signature_sha256/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2F%24defs%2Fsymbol%2Fproperties%2Fsource_span%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/span" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/$defs/symbol/properties/source_span/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2FoneOf%2F0%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/module" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/oneOf/0/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2FoneOf%2F1%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/symbol" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/oneOf/1/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2FoneOf%2F2%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/metadata" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/oneOf/2/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json/fact/reference/%2FoneOf%2F3%2F%24ref", + "convention": { + "dialect": "metadata.reference", + "namespace": "metadata.reference", + "version": "URI-reference" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "reference", + "native": { + "id": null, + "value": { + "network_access": false, + "resolution": "not-resolved", + "uri": "#/$defs/diagnostic" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "/oneOf/3/$ref" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/document/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/schema/msdmd%2Fmodule-projection.schema.json/fact/schema-description/lines%3A%3F-%3F/urn%3Athe-interdependency%3Amsdmd%3Amodule-projection%3A1", + "convention": { + "dialect": "json.schema", + "namespace": "json.schema", + "version": "https://json-schema.org/draft/2020-12/schema" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "schema-description", + "native": { + "id": "urn:the-interdependency:msdmd:module-projection:1", + "value": { + "$defs": { + "diagnostic": { + "additionalProperties": false, + "properties": { + "code": { + "minLength": 1, + "type": "string" + }, + "column": { + "minimum": 0, + "type": [ + "integer", + "null" + ] + }, + "line": { + "minimum": 1, + "type": [ + "integer", + "null" + ] + }, + "message": { + "type": "string" + }, + "record_type": { + "const": "diagnostic" + }, + "severity": { + "enum": [ + "error", + "warning", + "hmmm" + ] + }, + "source_path": { + "minLength": 1, + "type": "string" + } + }, + "required": [ + "record_type", + "code", + "severity", + "message", + "source_path" + ], + "type": "object" + }, + "metadata": { + "additionalProperties": false, + "properties": { + "attachment": { + "enum": [ + "native_docstring", + "leading_trivia", + "nearest_enclosing_symbol", + "module_convention", + "module_scope" + ] + }, + "convention": { + "minLength": 1, + "type": "string" + }, + "metadata_kind": { + "minLength": 1, + "type": "string" + }, + "record_type": { + "const": "metadata" + }, + "source_span": { + "$ref": "#/$defs/span" + }, + "standing": { + "enum": [ + "declared", + "syntactically_observed" + ] + }, + "subject": { + "minLength": 1, + "type": "string" + }, + "subject_kind": { + "minLength": 1, + "type": "string" + }, + "text": { + "type": "string" + } + }, + "required": [ + "record_type", + "metadata_kind", + "convention", + "subject", + "subject_kind", + "attachment", + "standing", + "text", + "source_span" + ], + "type": "object" + }, + "module": { + "additionalProperties": false, + "properties": { + "ast_feature_version": { + "pattern": "^[0-9]+\\.[0-9]+$", + "type": "string" + }, + "freshness_key_sha256": { + "$ref": "#/$defs/sha256" + }, + "hmmm": { + "items": { + "type": "string" + }, + "type": "array" + }, + "module_id": { + "minLength": 1, + "type": "string" + }, + "python_implementation": { + "minLength": 1, + "type": "string" + }, + "python_version": { + "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$", + "type": "string" + }, + "reader": { + "const": "the-interdependency.msdmd.python-ast-tokenize" + }, + "reader_manifest_sha256": { + "$ref": "#/$defs/sha256" + }, + "reader_sha256": { + "$ref": "#/$defs/sha256" + }, + "reader_version": { + "const": "1.0.0" + }, + "record_type": { + "const": "module" + }, + "repo": { + "minLength": 1, + "type": "string" + }, + "schema": { + "const": "urn:the-interdependency:msdmd:module-projection:1" + }, + "schema_sha256": { + "$ref": "#/$defs/sha256" + }, + "schema_version": { + "const": "1.0.0" + }, + "source_encoding": { + "minLength": 1, + "type": "string" + }, + "source_path": { + "minLength": 1, + "type": "string" + }, + "source_revision": { + "minLength": 1, + "type": "string" + }, + "source_sha256": { + "$ref": "#/$defs/sha256" + }, + "status": { + "enum": [ + "complete", + "invalid" + ] + } + }, + "required": [ + "record_type", + "schema", + "schema_version", + "schema_sha256", + "repo", + "source_revision", + "source_path", + "source_sha256", + "source_encoding", + "reader", + "reader_version", + "reader_sha256", + "reader_manifest_sha256", + "python_implementation", + "python_version", + "ast_feature_version", + "freshness_key_sha256", + "module_id", + "status", + "hmmm" + ], + "type": "object" + }, + "position": { + "additionalProperties": false, + "properties": { + "byte": { + "description": "Zero-based UTF-8 byte offset in the decoded source-text projection; source_sha256 identifies the authoritative raw bytes.", + "minimum": 0, + "type": "integer" + }, + "column": { + "description": "Zero-based Unicode character offset within the line.", + "minimum": 0, + "type": "integer" + }, + "line": { + "minimum": 1, + "type": "integer" + } + }, + "required": [ + "line", + "column", + "byte" + ], + "type": "object" + }, + "sha256": { + "pattern": "^[0-9a-f]{64}$", + "type": "string" + }, + "span": { + "additionalProperties": false, + "properties": { + "end": { + "$ref": "#/$defs/position" + }, + "start": { + "$ref": "#/$defs/position" + } + }, + "required": [ + "start", + "end" + ], + "type": "object" + }, + "symbol": { + "additionalProperties": false, + "properties": { + "decorators": { + "items": { + "type": "string" + }, + "type": "array" + }, + "id": { + "minLength": 1, + "type": "string" + }, + "kind": { + "enum": [ + "class", + "function", + "async_function", + "method", + "async_method" + ] + }, + "parent": { + "type": [ + "string", + "null" + ] + }, + "qualified_name": { + "minLength": 1, + "type": "string" + }, + "record_type": { + "const": "symbol" + }, + "signature": { + "minLength": 1, + "type": "string" + }, + "signature_sha256": { + "$ref": "#/$defs/sha256" + }, + "source_span": { + "$ref": "#/$defs/span" + }, + "standing": { + "const": "syntactically_observed" + } + }, + "required": [ + "record_type", + "id", + "kind", + "qualified_name", + "parent", + "signature", + "signature_sha256", + "decorators", + "standing", + "source_span" + ], + "type": "object" + } + }, + "$id": "urn:the-interdependency:msdmd:module-projection:1", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "description": "Schema for each line in a deterministic MSDMD Python module JSONL projection. The first line must be a module record; following lines are symbol, metadata, or diagnostic records.", + "oneOf": [ + { + "$ref": "#/$defs/module" + }, + { + "$ref": "#/$defs/symbol" + }, + { + "$ref": "#/$defs/metadata" + }, + { + "$ref": "#/$defs/diagnostic" + } + ], + "title": "MSDMD per-module projection record" + } + }, + "origin": "native", + "source": { + "content_sha256": "4e973475096ba1f38de2cedadc6335af19d93ec6f7b6d591d832359a324d8eca", + "file": "msdmd/module-projection.schema.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module-projection.schema.json#subject/schema/msdmd%2Fmodule-projection.schema.json", + "identity": "msdmd/module-projection.schema.json", + "scope": "schema" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "259:54" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A1180-1180/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "259:54" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1180, + "start_line": 1180 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "14:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A1180-1180/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "14:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1180, + "start_line": 1180 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "910:128" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A1180-1180/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "910:128" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1180, + "start_line": 1180 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=910:128 imports_exports=14:10 calls_definitions=259:54" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 77, + "column": 77, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: msdmd_python_module_projection\n module_name: module_projection\n module_kind: instrument\n summary: derives deterministic per-module JSONL metadata with structural symbol attachment from Python source without executing it\n owner: The Interdependency skill-lib\n public_surface: project_python_module, render_jsonl, project_tree, write_projections, check_projections\n internal_surface: Python symbol discovery, comment grouping, structural attachment, freshness computation\n auth_boundary: none\n storage_boundary: write\n network_boundary: none\n user_data_boundary: read\n admin_only: false\n tests: tests/test_module_projection.py\n rollout: explicit python -m msdmd.module_projection --write invocation\n rollback: remove the runner and generated projection directories; native sources remain authoritative\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 18, + "span": { + "end": { + "byte": 975, + "column": 26, + "line": 18 + }, + "start": { + "byte": 78, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CAPABILITIES ===\nid: python_module_metadata_projection\n exposes: deterministic JSONL projection, Python symbol identities, native docstrings, structurally attached comments, freshness key\n summary: creates one generated metadata sidecar per Python module while keeping source locations navigational rather than identity-bearing\n limitations: Python source only; call graphs, runtime behavior, cross-revision rename identity, and non-Python readers remain hmmm\n=== END CAPABILITIES ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 24, + "span": { + "end": { + "byte": 1479, + "column": 26, + "line": 24 + }, + "start": { + "byte": 976, + "column": 0, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CONTRACTS ===\nid: module_projection_line_shift_stability\n given: blank or comment lines are inserted without changing declaration structure\n then: metadata remains attached to the same qualified symbol identity after regeneration\n class: identity\n\nid: module_projection_never_executes_source\n given: inspected Python source contains executable top-level code\n then: projection parses bytes without importing or executing the inspected module\n class: safety\n\nid: module_projection_freshness_binds_source_and_reader\n given: source bytes, schema, reader implementation, support manifest, or effective Python AST grammar changes\n then: the deterministic projection freshness key changes\n class: provenance\n=== END CONTRACTS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 40, + "span": { + "end": { + "byte": 2246, + "column": 23, + "line": 40 + }, + "start": { + "byte": 1480, + "column": 0, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::<module>", + "metadata_kind": "comment", + "text": "Python recognizes only LF, CRLF, and CR as source newlines. str.splitlines()\nadditionally splits on U+2028, U+2029, NEL, form feed, and other separators,\nwhich would desynchronize line indexes from AST and tokenize positions." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 138, + "span": { + "end": { + "byte": 6221, + "column": 73, + "line": 138 + }, + "start": { + "byte": 5989, + "column": 0, + "line": 136 + } + }, + "start_line": 136 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/comment/5", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=910:128 imports_exports=14:10 calls_definitions=259:54" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1180, + "span": { + "end": { + "byte": 42541, + "column": 77, + "line": 1180 + }, + "start": { + "byte": 42464, + "column": 0, + "line": 1180 + } + }, + "start_line": 1180 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::<module>", + "description": "This runner is the first executable native-reader slice of MSDMD. Native\nsource remains authoritative; generated JSONL files are disposable projections.\nEach projection binds the source digest, reader digest, schema version, effective\nPython AST grammar, symbols, docstrings, comments, source spans, and attachment\nmethod.\n\nUsage::\n\n python -m msdmd.module_projection --root . --repo The-Interdependency/example --out-dir .msdmd/modules --write\n\n python -m msdmd.module_projection --root . --repo The-Interdependency/example --out-dir .msdmd/modules --check\n\nUse ``--source path/to/module.py`` one or more times to limit the selected\nmodules. A complete-tree ``--write`` replaces declared projection files and\nremoves stale JSONL projections below ``--out-dir``; a selected write never\nprunes files outside its selection. ``--check`` performs no writes and fails\nwhen a selected projection is missing, stale, or invalid. Complete-tree checks\nalso reject unexpected projections. No inspected module is imported or\nexecuted.\n\nAttachment rules:\n\n* a comment group immediately preceding a declaration at the same lexical\n depth is leading trivia for that declaration;\n* otherwise a comment inside a declaration, including comments before or\n between its decorators and trailing indented suite comments before lexical\n dedent, belongs to the nearest enclosing declaration;\n* headers, MSDMD fences, RATIOS, encoding cookies, and unattached comments stay\n at module scope;\n* native module/class/function docstrings attach directly to their AST owner.\n\nInterrupted, unclosed, or name-mismatched MSDMD fences, opening fences inside\nan open block, and closing fences without an opening produce diagnostics instead\nof spanning intervening code or being accepted as a block. A mismatch\n(wrong-name close or nested opening) yields one diagnostic: one later close per\naffected block name, orphaned by that already-reported mismatch, is suppressed\nuntil the next opening of that name. An interrupted fence may also report its\nlater closing fence as unmatched. This is stricter than the\nuniversal block parser, which matches each requested block name independently.\n\nSource lines are split only at Python newlines (LF, CRLF, and CR); U+2028, NEL,\nform feed, and other Unicode separators remain inside their physical line.\nLine and byte ranges are navigational facts for the pinned source digest. They\nnever form a symbol identity, so inserting lines cannot change ownership. Byte\noffsets index the UTF-8 re-encoding of the decoded source text, so they differ\nfrom raw file offsets for BOM-prefixed or non-UTF-8 sources.\nProjection files are written as exact UTF-8 bytes with LF record terminators on\nevery platform.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Generate deterministic, structurally attached Python module metadata.", + "text": "Generate deterministic, structurally attached Python module metadata.\n\nThis runner is the first executable native-reader slice of MSDMD. Native\nsource remains authoritative; generated JSONL files are disposable projections.\nEach projection binds the source digest, reader digest, schema version, effective\nPython AST grammar, symbols, docstrings, comments, source spans, and attachment\nmethod.\n\nUsage::\n\n python -m msdmd.module_projection --root . --repo The-Interdependency/example --out-dir .msdmd/modules --write\n\n python -m msdmd.module_projection --root . --repo The-Interdependency/example --out-dir .msdmd/modules --check\n\nUse ``--source path/to/module.py`` one or more times to limit the selected\nmodules. A complete-tree ``--write`` replaces declared projection files and\nremoves stale JSONL projections below ``--out-dir``; a selected write never\nprunes files outside its selection. ``--check`` performs no writes and fails\nwhen a selected projection is missing, stale, or invalid. Complete-tree checks\nalso reject unexpected projections. No inspected module is imported or\nexecuted.\n\nAttachment rules:\n\n* a comment group immediately preceding a declaration at the same lexical\n depth is leading trivia for that declaration;\n* otherwise a comment inside a declaration, including comments before or\n between its decorators and trailing indented suite comments before lexical\n dedent, belongs to the nearest enclosing declaration;\n* headers, MSDMD fences, RATIOS, encoding cookies, and unattached comments stay\n at module scope;\n* native module/class/function docstrings attach directly to their AST owner.\n\nInterrupted, unclosed, or name-mismatched MSDMD fences, opening fences inside\nan open block, and closing fences without an opening produce diagnostics instead\nof spanning intervening code or being accepted as a block. A mismatch\n(wrong-name close or nested opening) yields one diagnostic: one later close per\naffected block name, orphaned by that already-reported mismatch, is suppressed\nuntil the next opening of that name. An interrupted fence may also report its\nlater closing fence as unmatched. This is stricter than the\nuniversal block parser, which matches each requested block name independently.\n\nSource lines are split only at Python newlines (LF, CRLF, and CR); U+2028, NEL,\nform feed, and other Unicode separators remain inside their physical line.\nLine and byte ranges are navigational facts for the pinned source digest. They\nnever form a symbol identity, so inserting lines cannot change ownership. Byte\noffsets index the UTF-8 re-encoding of the decoded source text, so they differ\nfrom raw file offsets for BOM-prefixed or non-UTF-8 sources.\nProjection files are written as exact UTF-8 bytes with LF record terminators on\nevery platform.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 95, + "span": { + "end": { + "byte": 5084, + "column": 3, + "line": 95 + }, + "start": { + "byte": 2247, + "column": 0, + "line": 41 + } + }, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 96, + "start_line": 96 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 98, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:10", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 107, + "start_line": 107 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:11", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 108, + "start_line": 108 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/12", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tokenize:tokenize:12", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tokenize", + "name": "tokenize" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 109, + "start_line": 109 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/13", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterable:13", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 110, + "start_line": 110 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/14", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterator:14", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterator" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 110, + "start_line": 110 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/15", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Sequence:15", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Sequence" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 110, + "start_line": 110 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "ast:ast:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "ast", + "name": "ast" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 99, + "start_line": 99 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "codecs:codecs:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "codecs", + "name": "codecs" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 100, + "start_line": 100 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "dataclasses:dataclass:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "dataclasses", + "name": "dataclass" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 101, + "start_line": 101 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 102, + "start_line": 102 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:6", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 103, + "start_line": 103 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:7", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 104, + "start_line": 104 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 105, + "start_line": 105 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:9", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 106, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/module/msdmd%2Fmodule_projection.py", + "identity": "msdmd/module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentDiagnostic/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "CommentDiagnostic", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::class:CommentDiagnostic", + "decorators": [ + "dataclass(frozen=True)" + ], + "kind": "class", + "name": "CommentDiagnostic", + "parent_identity": null, + "qualified_name": "CommentDiagnostic", + "signature": "class CommentDiagnostic" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 331, + "span": { + "end": { + "byte": 11427, + "column": 27, + "line": 331 + }, + "start": { + "byte": 11320, + "column": 0, + "line": 327 + } + }, + "start_line": 327 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentDiagnostic", + "identity": "CommentDiagnostic", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup.end_column/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CommentGroup.end_column", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::method:CommentGroup.end_column", + "decorators": [ + "property" + ], + "kind": "method", + "name": "end_column", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::class:CommentGroup", + "qualified_name": "CommentGroup.end_column", + "signature": "def end_column(self) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 314, + "span": { + "end": { + "byte": 11037, + "column": 37, + "line": 314 + }, + "start": { + "byte": 10957, + "column": 4, + "line": 312 + } + }, + "start_line": 312 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup.end_column", + "identity": "CommentGroup.end_column", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup.end_line/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CommentGroup.end_line", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::method:CommentGroup.end_line", + "decorators": [ + "property" + ], + "kind": "method", + "name": "end_line", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::class:CommentGroup", + "qualified_name": "CommentGroup.end_line", + "signature": "def end_line(self) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 310, + "span": { + "end": { + "byte": 10951, + "column": 37, + "line": 310 + }, + "start": { + "byte": 10873, + "column": 4, + "line": 308 + } + }, + "start_line": 308 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup.end_line", + "identity": "CommentGroup.end_line", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup.start_column/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CommentGroup.start_column", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::method:CommentGroup.start_column", + "decorators": [ + "property" + ], + "kind": "method", + "name": "start_column", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::class:CommentGroup", + "qualified_name": "CommentGroup.start_column", + "signature": "def start_column(self) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 306, + "span": { + "end": { + "byte": 10867, + "column": 38, + "line": 306 + }, + "start": { + "byte": 10784, + "column": 4, + "line": 304 + } + }, + "start_line": 304 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup.start_column", + "identity": "CommentGroup.start_column", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup.start_line/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CommentGroup.start_line", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::method:CommentGroup.start_line", + "decorators": [ + "property" + ], + "kind": "method", + "name": "start_line", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::class:CommentGroup", + "qualified_name": "CommentGroup.start_line", + "signature": "def start_line(self) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 302, + "span": { + "end": { + "byte": 10778, + "column": 38, + "line": 302 + }, + "start": { + "byte": 10697, + "column": 4, + "line": 300 + } + }, + "start_line": 300 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup.start_line", + "identity": "CommentGroup.start_line", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup.text_lines/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CommentGroup.text_lines", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::method:CommentGroup.text_lines", + "decorators": [ + "property" + ], + "kind": "method", + "name": "text_lines", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::class:CommentGroup", + "qualified_name": "CommentGroup.text_lines", + "signature": "def text_lines(self) -> tuple[str, ...]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 324, + "span": { + "end": { + "byte": 11317, + "column": 28, + "line": 324 + }, + "start": { + "byte": 11043, + "column": 4, + "line": 316 + } + }, + "start_line": 316 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup.text_lines", + "identity": "CommentGroup.text_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "CommentGroup", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::class:CommentGroup", + "decorators": [ + "dataclass(frozen=True)" + ], + "kind": "class", + "name": "CommentGroup", + "parent_identity": null, + "qualified_name": "CommentGroup", + "signature": "class CommentGroup" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 324, + "span": { + "end": { + "byte": 11317, + "column": 28, + "line": 324 + }, + "start": { + "byte": 10605, + "column": 0, + "line": 296 + } + }, + "start_line": 296 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/CommentGroup", + "identity": "CommentGroup", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/Symbol.column/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "Symbol.column", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::method:Symbol.column", + "decorators": [ + "property" + ], + "kind": "method", + "name": "column", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::class:Symbol", + "qualified_name": "Symbol.column", + "signature": "def column(self) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 293, + "span": { + "end": { + "byte": 10602, + "column": 40, + "line": 293 + }, + "start": { + "byte": 10523, + "column": 4, + "line": 291 + } + }, + "start_line": 291 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/Symbol.column", + "identity": "Symbol.column", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/Symbol.end_line/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "Symbol.end_line", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::method:Symbol.end_line", + "decorators": [ + "property" + ], + "kind": "method", + "name": "end_line", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::class:Symbol", + "qualified_name": "Symbol.end_line", + "signature": "def end_line(self) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 289, + "span": { + "end": { + "byte": 10517, + "column": 60, + "line": 289 + }, + "start": { + "byte": 10416, + "column": 4, + "line": 287 + } + }, + "start_line": 287 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/Symbol.end_line", + "identity": "Symbol.end_line", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/Symbol.start_line/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "Symbol.start_line", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::method:Symbol.start_line", + "decorators": [ + "property" + ], + "kind": "method", + "name": "start_line", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::class:Symbol", + "qualified_name": "Symbol.start_line", + "signature": "def start_line(self) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 285, + "span": { + "end": { + "byte": 10410, + "column": 36, + "line": 285 + }, + "start": { + "byte": 10331, + "column": 4, + "line": 283 + } + }, + "start_line": 283 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/Symbol.start_line", + "identity": "Symbol.start_line", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/Symbol/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "Symbol", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::class:Symbol", + "decorators": [ + "dataclass(frozen=True)" + ], + "kind": "class", + "name": "Symbol", + "parent_identity": null, + "qualified_name": "Symbol", + "signature": "class Symbol" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 293, + "span": { + "end": { + "byte": 10602, + "column": 40, + "line": 293 + }, + "start": { + "byte": 10055, + "column": 0, + "line": 271 + } + }, + "start_line": 271 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/Symbol", + "identity": "Symbol", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_byte_line_reader.readline/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_byte_line_reader.readline", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_byte_line_reader.readline", + "decorators": [], + "kind": "function", + "name": "readline", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_byte_line_reader", + "qualified_name": "_byte_line_reader.readline", + "signature": "def readline() -> bytes" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 203, + "span": { + "end": { + "byte": 8172, + "column": 34, + "line": 203 + }, + "start": { + "byte": 8113, + "column": 4, + "line": 202 + } + }, + "start_line": 202 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_byte_line_reader.readline", + "identity": "_byte_line_reader.readline", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_byte_line_reader/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_byte_line_reader", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_byte_line_reader", + "decorators": [], + "kind": "function", + "name": "_byte_line_reader", + "parent_identity": null, + "qualified_name": "_byte_line_reader", + "signature": "def _byte_line_reader(source: bytes)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 205, + "span": { + "end": { + "byte": 8193, + "column": 19, + "line": 205 + }, + "start": { + "byte": 7933, + "column": 0, + "line": 197 + } + }, + "start_line": 197 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_byte_line_reader", + "identity": "_byte_line_reader", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_byte_line_reader/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_byte_line_reader", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return a readline callable that yields Python-newline-delimited lines.", + "text": "Return a readline callable that yields Python-newline-delimited lines." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 198, + "span": { + "end": { + "byte": 8051, + "column": 80, + "line": 198 + }, + "start": { + "byte": 7975, + "column": 4, + "line": 198 + } + }, + "start_line": 198 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_byte_line_reader", + "identity": "_byte_line_reader", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_byte_offset/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_byte_offset", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_byte_offset", + "decorators": [], + "kind": "function", + "name": "_byte_offset", + "parent_identity": null, + "qualified_name": "_byte_offset", + "signature": "def _byte_offset(lines: Sequence[str], starts: Sequence[int], line: int, column: int) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 222, + "span": { + "end": { + "byte": 8702, + "column": 59, + "line": 222 + }, + "start": { + "byte": 8403, + "column": 0, + "line": 217 + } + }, + "start_line": 217 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_byte_offset", + "identity": "_byte_offset", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_canonical_json/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_canonical_json", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_canonical_json", + "decorators": [], + "kind": "function", + "name": "_canonical_json", + "parent_identity": null, + "qualified_name": "_canonical_json", + "signature": "def _canonical_json(value: object) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 148, + "span": { + "end": { + "byte": 6534, + "column": 87, + "line": 148 + }, + "start": { + "byte": 6404, + "column": 0, + "line": 147 + } + }, + "start_line": 147 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_canonical_json", + "identity": "_canonical_json", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups.flush/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_comment_groups.flush", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_comment_groups.flush", + "decorators": [], + "kind": "function", + "name": "flush", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_comment_groups", + "qualified_name": "_comment_groups.flush", + "signature": "def flush() -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 504, + "span": { + "end": { + "byte": 18781, + "column": 24, + "line": 504 + }, + "start": { + "byte": 18656, + "column": 4, + "line": 500 + } + }, + "start_line": 500 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups.flush", + "identity": "_comment_groups.flush", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_comment_groups", + "metadata_kind": "comment", + "text": "Tokenize the decoded Python-newline line map with each terminator\nnormalized to LF. A raw byte readline would deliver a CR-only file as one\nline, desynchronizing comment positions from AST line numbers. Line\nnumbers and in-line columns are unchanged by terminator normalization." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 476, + "span": { + "end": { + "byte": 17690, + "column": 76, + "line": 476 + }, + "start": { + "byte": 17390, + "column": 4, + "line": 473 + } + }, + "start_line": 473 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups", + "identity": "_comment_groups", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_comment_groups", + "metadata_kind": "comment", + "text": "Closing fences left orphaned by an already-diagnosed mismatch are\nfollow-on noise: suppress one close per affected block name, until the\nnext opening of that name, so a mismatch yields one diagnostic.\nInterrupted fences are not covered. The projection remains invalid." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 497, + "span": { + "end": { + "byte": 18607, + "column": 74, + "line": 497 + }, + "start": { + "byte": 18318, + "column": 4, + "line": 494 + } + }, + "start_line": 494 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups", + "identity": "_comment_groups", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_comment_groups", + "metadata_kind": "comment", + "text": "A closing fence must name the open block; an opening\nfence inside an open block is equally unpaired. Neither\nmay be accepted as a well-formed MSDMD block." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 529, + "span": { + "end": { + "byte": 19844, + "column": 67, + "line": 529 + }, + "start": { + "byte": 19643, + "column": 20, + "line": 527 + } + }, + "start_line": 527 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups", + "identity": "_comment_groups", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_comment_groups", + "metadata_kind": "comment", + "text": "A new opening of this name ends any suppression left by an\nearlier mismatch, so later genuine orphans remain visible." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 571, + "span": { + "end": { + "byte": 21764, + "column": 72, + "line": 571 + }, + "start": { + "byte": 21631, + "column": 12, + "line": 570 + } + }, + "start_line": 570 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups", + "identity": "_comment_groups", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_comment_groups", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_comment_groups", + "decorators": [], + "kind": "function", + "name": "_comment_groups", + "parent_identity": null, + "qualified_name": "_comment_groups", + "signature": "def _comment_groups(lines: Sequence[str], encoding_cookie_line: int | None) -> tuple[list[CommentGroup], list[CommentDiagnostic]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 616, + "span": { + "end": { + "byte": 23295, + "column": 72, + "line": 616 + }, + "start": { + "byte": 17154, + "column": 0, + "line": 467 + } + }, + "start_line": 467 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_groups", + "identity": "_comment_groups", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_record/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_comment_record", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_comment_record", + "decorators": [], + "kind": "function", + "name": "_comment_record", + "parent_identity": null, + "qualified_name": "_comment_record", + "signature": "def _comment_record(group: CommentGroup, subject: str, subject_kind: str, attachment: str, metadata_kind: str, lines: Sequence[str], starts: Sequence[int]) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 763, + "span": { + "end": { + "byte": 27893, + "column": 5, + "line": 763 + }, + "start": { + "byte": 27168, + "column": 0, + "line": 737 + } + }, + "start_line": 737 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_comment_record", + "identity": "_comment_record", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_discover_symbols.visit_node/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_discover_symbols.visit_node", + "metadata_kind": "comment", + "text": "Control-flow nodes and their non-statement suite containers do not\ncreate lexical symbol scopes. Recurse through match_case,\nExceptHandler, and equivalent AST nodes while stopping at each\ndiscovered declaration boundary above." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 409, + "span": { + "end": { + "byte": 15017, + "column": 48, + "line": 409 + }, + "start": { + "byte": 14759, + "column": 8, + "line": 406 + } + }, + "start_line": 406 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_discover_symbols.visit_node", + "identity": "_discover_symbols.visit_node", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_discover_symbols.visit_node/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_discover_symbols.visit_node", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_discover_symbols.visit_node", + "decorators": [], + "kind": "function", + "name": "visit_node", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_discover_symbols", + "qualified_name": "_discover_symbols.visit_node", + "signature": "def visit_node(node: ast.AST, names: tuple[str, ...], parent_kind: str | None, parent_key: str | None, depth: int) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 411, + "span": { + "end": { + "byte": 15135, + "column": 68, + "line": 411 + }, + "start": { + "byte": 13982, + "column": 4, + "line": 387 + } + }, + "start_line": 387 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_discover_symbols.visit_node", + "identity": "_discover_symbols.visit_node", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_discover_symbols/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_discover_symbols", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_discover_symbols", + "decorators": [], + "kind": "function", + "name": "_discover_symbols", + "parent_identity": null, + "qualified_name": "_discover_symbols", + "signature": "def _discover_symbols(tree: ast.Module, repo: str, source_path: str) -> list[Symbol]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 452, + "span": { + "end": { + "byte": 16778, + "column": 18, + "line": 452 + }, + "start": { + "byte": 13807, + "column": 0, + "line": 384 + } + }, + "start_line": 384 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_discover_symbols", + "identity": "_discover_symbols", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_docstring_record/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_docstring_record", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_docstring_record", + "decorators": [], + "kind": "function", + "name": "_docstring_record", + "parent_identity": null, + "qualified_name": "_docstring_record", + "signature": "def _docstring_record(owner: ast.Module | ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef, subject: str, subject_kind: str, lines: Sequence[str], starts: Sequence[int]) -> dict | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 734, + "span": { + "end": { + "byte": 27165, + "column": 5, + "line": 734 + }, + "start": { + "byte": 26309, + "column": 0, + "line": 708 + } + }, + "start_line": 708 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_docstring_record", + "identity": "_docstring_record", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_enclosing_subject/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_enclosing_subject", + "metadata_kind": "comment", + "text": "A declaration's lexical region begins at its first decorator, so comments\nbefore or between decorators (and inside decorator expressions) belong to\nthe decorated declaration rather than drifting to an outer scope." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 666, + "span": { + "end": { + "byte": 24975, + "column": 71, + "line": 666 + }, + "start": { + "byte": 24748, + "column": 4, + "line": 664 + } + }, + "start_line": 664 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_enclosing_subject", + "identity": "_enclosing_subject", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_enclosing_subject/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_enclosing_subject", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_enclosing_subject", + "decorators": [], + "kind": "function", + "name": "_enclosing_subject", + "parent_identity": null, + "qualified_name": "_enclosing_subject", + "signature": "def _enclosing_subject(group: CommentGroup, symbols: Sequence[Symbol], lines: Sequence[str]) -> Symbol | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 679, + "span": { + "end": { + "byte": 25422, + "column": 98, + "line": 679 + }, + "start": { + "byte": 24618, + "column": 0, + "line": 659 + } + }, + "start_line": 659 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_enclosing_subject", + "identity": "_enclosing_subject", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_encoding_cookie_line/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_encoding_cookie_line", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_encoding_cookie_line", + "decorators": [], + "kind": "function", + "name": "_encoding_cookie_line", + "parent_identity": null, + "qualified_name": "_encoding_cookie_line", + "signature": "def _encoding_cookie_line(source: bytes) -> int | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 464, + "span": { + "end": { + "byte": 17151, + "column": 52, + "line": 464 + }, + "start": { + "byte": 16781, + "column": 0, + "line": 455 + } + }, + "start_line": 455 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_encoding_cookie_line", + "identity": "_encoding_cookie_line", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_freshness_key/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_freshness_key", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_freshness_key", + "decorators": [], + "kind": "function", + "name": "_freshness_key", + "parent_identity": null, + "qualified_name": "_freshness_key", + "signature": "def _freshness_key(repo: str, source_path: str, source_sha256: str, reader_sha256: str, schema_sha256: str, reader_manifest_sha256: str, source_revision: str, runtime_identity: dict[str, str]) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 790, + "span": { + "end": { + "byte": 28666, + "column": 61, + "line": 790 + }, + "start": { + "byte": 27896, + "column": 0, + "line": 766 + } + }, + "start_line": 766 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_freshness_key", + "identity": "_freshness_key", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_header_line/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_header_line", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_header_line", + "decorators": [], + "kind": "function", + "name": "_header_line", + "parent_identity": null, + "qualified_name": "_header_line", + "signature": "def _header_line(node: ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 381, + "span": { + "end": { + "byte": 13804, + "column": 47, + "line": 381 + }, + "start": { + "byte": 13603, + "column": 0, + "line": 379 + } + }, + "start_line": 379 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_header_line", + "identity": "_header_line", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_iter_python_sources.walk/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_iter_python_sources.walk", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_iter_python_sources.walk", + "decorators": [], + "kind": "function", + "name": "walk", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_iter_python_sources", + "qualified_name": "_iter_python_sources.walk", + "signature": "def walk(directory: Path) -> Iterator[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1018, + "span": { + "end": { + "byte": 36288, + "column": 27, + "line": 1018 + }, + "start": { + "byte": 35867, + "column": 4, + "line": 1009 + } + }, + "start_line": 1009 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_iter_python_sources.walk", + "identity": "_iter_python_sources.walk", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_iter_python_sources/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_iter_python_sources", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_iter_python_sources", + "decorators": [], + "kind": "function", + "name": "_iter_python_sources", + "parent_identity": null, + "qualified_name": "_iter_python_sources", + "signature": "def _iter_python_sources(root: Path, selected: Sequence[Path]=()) -> Iterator[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1020, + "span": { + "end": { + "byte": 36315, + "column": 25, + "line": 1020 + }, + "start": { + "byte": 35423, + "column": 0, + "line": 998 + } + }, + "start_line": 998 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_iter_python_sources", + "identity": "_iter_python_sources", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_kind/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_kind", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_kind", + "decorators": [], + "kind": "function", + "name": "_kind", + "parent_identity": null, + "qualified_name": "_kind", + "signature": "def _kind(node: ast.AST, parent_kind: str | None) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 376, + "span": { + "end": { + "byte": 13600, + "column": 85, + "line": 376 + }, + "start": { + "byte": 13278, + "column": 0, + "line": 371 + } + }, + "start_line": 371 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_kind", + "identity": "_kind", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_leading_subject/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_leading_subject", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_leading_subject", + "decorators": [], + "kind": "function", + "name": "_leading_subject", + "parent_identity": null, + "qualified_name": "_leading_subject", + "signature": "def _leading_subject(group: CommentGroup, symbols: Sequence[Symbol]) -> Symbol | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 643, + "span": { + "end": { + "byte": 24193, + "column": 82, + "line": 643 + }, + "start": { + "byte": 23819, + "column": 0, + "line": 635 + } + }, + "start_line": 635 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_leading_subject", + "identity": "_leading_subject", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_lexical_end_line/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_lexical_end_line", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_lexical_end_line", + "decorators": [], + "kind": "function", + "name": "_lexical_end_line", + "parent_identity": null, + "qualified_name": "_lexical_end_line", + "signature": "def _lexical_end_line(symbol: Symbol, lines: Sequence[str]) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 656, + "span": { + "end": { + "byte": 24615, + "column": 19, + "line": 656 + }, + "start": { + "byte": 24196, + "column": 0, + "line": 646 + } + }, + "start_line": 646 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_lexical_end_line", + "identity": "_lexical_end_line", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_line_start_bytes/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_line_start_bytes", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_line_start_bytes", + "decorators": [], + "kind": "function", + "name": "_line_start_bytes", + "parent_identity": null, + "qualified_name": "_line_start_bytes", + "signature": "def _line_start_bytes(lines: Sequence[str]) -> list[int]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 214, + "span": { + "end": { + "byte": 8400, + "column": 18, + "line": 214 + }, + "start": { + "byte": 8196, + "column": 0, + "line": 208 + } + }, + "start_line": 208 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_line_start_bytes", + "identity": "_line_start_bytes", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_module_address/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_module_address", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_module_address", + "decorators": [], + "kind": "function", + "name": "_module_address", + "parent_identity": null, + "qualified_name": "_module_address", + "signature": "def _module_address(repo: str, source_path: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 268, + "span": { + "end": { + "byte": 10052, + "column": 51, + "line": 268 + }, + "start": { + "byte": 9944, + "column": 0, + "line": 267 + } + }, + "start_line": 267 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_module_address", + "identity": "_module_address", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_node_span.character_column/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_node_span.character_column", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_node_span.character_column", + "decorators": [], + "kind": "function", + "name": "character_column", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_node_span", + "qualified_name": "_node_span.character_column", + "signature": "def character_column(line: int, utf8_byte_column: int) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 253, + "span": { + "end": { + "byte": 9586, + "column": 42, + "line": 253 + }, + "start": { + "byte": 9309, + "column": 4, + "line": 248 + } + }, + "start_line": 248 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_node_span.character_column", + "identity": "_node_span.character_column", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_node_span/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_node_span", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_node_span", + "decorators": [], + "kind": "function", + "name": "_node_span", + "parent_identity": null, + "qualified_name": "_node_span", + "signature": "def _node_span(node: ast.AST, lines: Sequence[str], starts: Sequence[int]) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 264, + "span": { + "end": { + "byte": 9941, + "column": 5, + "line": 264 + }, + "start": { + "byte": 9221, + "column": 0, + "line": 247 + } + }, + "start_line": 247 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_node_span", + "identity": "_node_span", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_projection_target/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_projection_target", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_projection_target", + "decorators": [], + "kind": "function", + "name": "_projection_target", + "parent_identity": null, + "qualified_name": "_projection_target", + "signature": "def _projection_target(out_dir: Path, relative: str) -> Path" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1050, + "span": { + "end": { + "byte": 37337, + "column": 17, + "line": 1050 + }, + "start": { + "byte": 36908, + "column": 0, + "line": 1042 + } + }, + "start_line": 1042 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_projection_target", + "identity": "_projection_target", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_python_source_byte_lines/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_python_source_byte_lines", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_python_source_byte_lines", + "decorators": [], + "kind": "function", + "name": "_python_source_byte_lines", + "parent_identity": null, + "qualified_name": "_python_source_byte_lines", + "signature": "def _python_source_byte_lines(source: bytes) -> list[bytes]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 194, + "span": { + "end": { + "byte": 7930, + "column": 16, + "line": 194 + }, + "start": { + "byte": 7529, + "column": 0, + "line": 184 + } + }, + "start_line": 184 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_python_source_byte_lines", + "identity": "_python_source_byte_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_python_source_byte_lines/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_python_source_byte_lines", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Split raw source bytes at Python newlines only, keeping line endings.", + "text": "Split raw source bytes at Python newlines only, keeping line endings." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 185, + "span": { + "end": { + "byte": 7669, + "column": 79, + "line": 185 + }, + "start": { + "byte": 7594, + "column": 4, + "line": 185 + } + }, + "start_line": 185 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_python_source_byte_lines", + "identity": "_python_source_byte_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_python_source_lines/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_python_source_lines", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_python_source_lines", + "decorators": [], + "kind": "function", + "name": "_python_source_lines", + "parent_identity": null, + "qualified_name": "_python_source_lines", + "signature": "def _python_source_lines(text: str) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 181, + "span": { + "end": { + "byte": 7526, + "column": 16, + "line": 181 + }, + "start": { + "byte": 7154, + "column": 0, + "line": 171 + } + }, + "start_line": 171 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_python_source_lines", + "identity": "_python_source_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_python_source_lines/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_python_source_lines", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Split decoded source at Python newlines only, keeping line endings.", + "text": "Split decoded source at Python newlines only, keeping line endings." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 172, + "span": { + "end": { + "byte": 7281, + "column": 77, + "line": 172 + }, + "start": { + "byte": 7208, + "column": 4, + "line": 172 + } + }, + "start_line": 172 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_python_source_lines", + "identity": "_python_source_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_reader_manifest_sha256/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_reader_manifest_sha256", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_reader_manifest_sha256", + "decorators": [], + "kind": "function", + "name": "_reader_manifest_sha256", + "parent_identity": null, + "qualified_name": "_reader_manifest_sha256", + "signature": "def _reader_manifest_sha256() -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 160, + "span": { + "end": { + "byte": 6862, + "column": 86, + "line": 160 + }, + "start": { + "byte": 6738, + "column": 0, + "line": 159 + } + }, + "start_line": 159 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_reader_manifest_sha256", + "identity": "_reader_manifest_sha256", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_reader_sha256/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_reader_sha256", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_reader_sha256", + "decorators": [], + "kind": "function", + "name": "_reader_sha256", + "parent_identity": null, + "qualified_name": "_reader_sha256", + "signature": "def _reader_sha256() -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 152, + "span": { + "end": { + "byte": 6613, + "column": 47, + "line": 152 + }, + "start": { + "byte": 6537, + "column": 0, + "line": 151 + } + }, + "start_line": 151 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_reader_sha256", + "identity": "_reader_sha256", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_runtime_identity/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_runtime_identity", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_runtime_identity", + "decorators": [], + "kind": "function", + "name": "_runtime_identity", + "parent_identity": null, + "qualified_name": "_runtime_identity", + "signature": "def _runtime_identity() -> dict[str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 168, + "span": { + "end": { + "byte": 7151, + "column": 5, + "line": 168 + }, + "start": { + "byte": 6865, + "column": 0, + "line": 163 + } + }, + "start_line": 163 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_runtime_identity", + "identity": "_runtime_identity", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_schema_sha256/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_schema_sha256", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_schema_sha256", + "decorators": [], + "kind": "function", + "name": "_schema_sha256", + "parent_identity": null, + "qualified_name": "_schema_sha256", + "signature": "def _schema_sha256() -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 156, + "span": { + "end": { + "byte": 6735, + "column": 90, + "line": 156 + }, + "start": { + "byte": 6616, + "column": 0, + "line": 155 + } + }, + "start_line": 155 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_schema_sha256", + "identity": "_schema_sha256", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_selected_sources/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_selected_sources", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_selected_sources", + "decorators": [], + "kind": "function", + "name": "_selected_sources", + "parent_identity": null, + "qualified_name": "_selected_sources", + "signature": "def _selected_sources(root: Path, values: Iterable[str]) -> list[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1126, + "span": { + "end": { + "byte": 40384, + "column": 45, + "line": 1126 + }, + "start": { + "byte": 40267, + "column": 0, + "line": 1125 + } + }, + "start_line": 1125 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_selected_sources", + "identity": "_selected_sources", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_sha256/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_sha256", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_sha256", + "decorators": [], + "kind": "function", + "name": "_sha256", + "parent_identity": null, + "qualified_name": "_sha256", + "signature": "def _sha256(data: bytes) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 144, + "span": { + "end": { + "byte": 6401, + "column": 43, + "line": 144 + }, + "start": { + "byte": 6325, + "column": 0, + "line": 143 + } + }, + "start_line": 143 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_sha256", + "identity": "_sha256", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_signature/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_signature", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_signature", + "decorators": [], + "kind": "function", + "name": "_signature", + "parent_identity": null, + "qualified_name": "_signature", + "signature": "def _signature(node: ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef) -> tuple[str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 368, + "span": { + "end": { + "byte": 13275, + "column": 72, + "line": 368 + }, + "start": { + "byte": 11430, + "column": 0, + "line": 334 + } + }, + "start_line": 334 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_signature", + "identity": "_signature", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_span/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_span", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_span", + "decorators": [], + "kind": "function", + "name": "_span", + "parent_identity": null, + "qualified_name": "_span", + "signature": "def _span(lines: Sequence[str], starts: Sequence[int], start_line: int, start_column: int, end_line: int, end_column: int) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 244, + "span": { + "end": { + "byte": 9218, + "column": 5, + "line": 244 + }, + "start": { + "byte": 8705, + "column": 0, + "line": 225 + } + }, + "start_line": 225 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_span", + "identity": "_span", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_special_comment_kind/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_special_comment_kind", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_special_comment_kind", + "decorators": [], + "kind": "function", + "name": "_special_comment_kind", + "parent_identity": null, + "qualified_name": "_special_comment_kind", + "signature": "def _special_comment_kind(group: CommentGroup, encoding_cookie_line: int | None) -> str | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 632, + "span": { + "end": { + "byte": 23816, + "column": 15, + "line": 632 + }, + "start": { + "byte": 23298, + "column": 0, + "line": 619 + } + }, + "start_line": 619 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_special_comment_kind", + "identity": "_special_comment_kind", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_symbol_record/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_symbol_record", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:_symbol_record", + "decorators": [], + "kind": "function", + "name": "_symbol_record", + "parent_identity": null, + "qualified_name": "_symbol_record", + "signature": "def _symbol_record(symbol: Symbol, lines: Sequence[str], starts: Sequence[int]) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 705, + "span": { + "end": { + "byte": 26306, + "column": 5, + "line": 705 + }, + "start": { + "byte": 25425, + "column": 0, + "line": 682 + } + }, + "start_line": 682 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/_symbol_record", + "identity": "_symbol_record", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/check_projections/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "check_projections", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:check_projections", + "decorators": [], + "kind": "function", + "name": "check_projections", + "parent_identity": null, + "qualified_name": "check_projections", + "signature": "def check_projections(out_dir: Path, projections: dict[str, str], *, check_unexpected: bool=False) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1122, + "span": { + "end": { + "byte": 40264, + "column": 19, + "line": 1122 + }, + "start": { + "byte": 39091, + "column": 0, + "line": 1098 + } + }, + "start_line": 1098 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/check_projections", + "identity": "check_projections", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/check_projections/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:check_projections", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return deterministic freshness and diagnostic findings without writing.", + "text": "Return deterministic freshness and diagnostic findings without writing." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1104, + "span": { + "end": { + "byte": 39306, + "column": 81, + "line": 1104 + }, + "start": { + "byte": 39229, + "column": 4, + "line": 1104 + } + }, + "start_line": 1104 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/check_projections", + "identity": "check_projections", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: list[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1175, + "span": { + "end": { + "byte": 42405, + "column": 31, + "line": 1175 + }, + "start": { + "byte": 40387, + "column": 0, + "line": 1129 + } + }, + "start_line": 1129 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_python_bytes/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "project_python_bytes", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:project_python_bytes", + "decorators": [], + "kind": "function", + "name": "project_python_bytes", + "parent_identity": null, + "qualified_name": "project_python_bytes", + "signature": "def project_python_bytes(source: bytes, *, source_path: str, repo: str, revision: str | None=None) -> list[dict]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 985, + "span": { + "end": { + "byte": 35121, + "column": 18, + "line": 985 + }, + "start": { + "byte": 29369, + "column": 0, + "line": 816 + } + }, + "start_line": 816 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_python_bytes", + "identity": "project_python_bytes", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_python_bytes/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:project_python_bytes", + "description": "The path is provenance only. Both the standalone file runner and unified\ncollector call this same syntax/attachment implementation.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Project an already-bounded immutable buffer; never reopen the inspected file.", + "text": "Project an already-bounded immutable buffer; never reopen the inspected file.\n\n The path is provenance only. Both the standalone file runner and unified\n collector call this same syntax/attachment implementation.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 823, + "span": { + "end": { + "byte": 29725, + "column": 7, + "line": 823 + }, + "start": { + "byte": 29496, + "column": 4, + "line": 819 + } + }, + "start_line": 819 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_python_bytes", + "identity": "project_python_bytes", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_python_module/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "project_python_module", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:project_python_module", + "decorators": [], + "kind": "function", + "name": "project_python_module", + "parent_identity": null, + "qualified_name": "project_python_module", + "signature": "def project_python_module(path: Path, *, root: Path, repo: str, revision: str | None=None) -> list[dict]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 813, + "span": { + "end": { + "byte": 29366, + "column": 106, + "line": 813 + }, + "start": { + "byte": 28669, + "column": 0, + "line": 793 + } + }, + "start_line": 793 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_python_module", + "identity": "project_python_module", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_python_module/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:project_python_module", + "description": "``path`` must resolve within ``root``. Invalid syntax produces a module\nrecord plus a diagnostic record; the source is never imported or executed.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return deterministic projection records for one Python source file.", + "text": "Return deterministic projection records for one Python source file.\n\n ``path`` must resolve within ``root``. Invalid syntax produces a module\n record plus a diagnostic record; the source is never imported or executed.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 804, + "span": { + "end": { + "byte": 29039, + "column": 7, + "line": 804 + }, + "start": { + "byte": 28804, + "column": 4, + "line": 800 + } + }, + "start_line": 800 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_python_module", + "identity": "project_python_module", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_tree/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "project_tree", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:project_tree", + "decorators": [], + "kind": "function", + "name": "project_tree", + "parent_identity": null, + "qualified_name": "project_tree", + "signature": "def project_tree(root: Path, repo: str, *, sources: Sequence[Path]=(), revision: str | None=None) -> dict[str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1039, + "span": { + "end": { + "byte": 36905, + "column": 22, + "line": 1039 + }, + "start": { + "byte": 36318, + "column": 0, + "line": 1023 + } + }, + "start_line": 1023 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_tree", + "identity": "project_tree", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_tree/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:project_tree", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return ``relative sidecar path -> deterministic JSONL`` for Python files.", + "text": "Return ``relative sidecar path -> deterministic JSONL`` for Python files." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1030, + "span": { + "end": { + "byte": 36545, + "column": 83, + "line": 1030 + }, + "start": { + "byte": 36466, + "column": 4, + "line": 1030 + } + }, + "start_line": 1030 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/project_tree", + "identity": "project_tree", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/render_jsonl/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "render_jsonl", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:render_jsonl", + "decorators": [], + "kind": "function", + "name": "render_jsonl", + "parent_identity": null, + "qualified_name": "render_jsonl", + "signature": "def render_jsonl(records: Sequence[dict]) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 995, + "span": { + "end": { + "byte": 35420, + "column": 72, + "line": 995 + }, + "start": { + "byte": 35124, + "column": 0, + "line": 988 + } + }, + "start_line": 988 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/render_jsonl", + "identity": "render_jsonl", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/render_jsonl/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:render_jsonl", + "description": "Callers persist ``content.encode(\"utf-8\")`` exactly; see\n``write_projections``.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Render records as deterministic JSON Lines text with LF terminators.", + "text": "Render records as deterministic JSON Lines text with LF terminators.\n\n Callers persist ``content.encode(\"utf-8\")`` exactly; see\n ``write_projections``.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 993, + "span": { + "end": { + "byte": 35346, + "column": 7, + "line": 993 + }, + "start": { + "byte": 35178, + "column": 4, + "line": 989 + } + }, + "start_line": 989 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/render_jsonl", + "identity": "render_jsonl", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/write_projections/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:write_projections", + "metadata_kind": "comment", + "text": "Binary mode: text mode would translate LF to os.linesep\n(CRLF on Windows) and break byte-exact write/check convergence." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1077, + "span": { + "end": { + "byte": 38394, + "column": 81, + "line": 1077 + }, + "start": { + "byte": 38255, + "column": 16, + "line": 1076 + } + }, + "start_line": 1076 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/write_projections", + "identity": "write_projections", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/write_projections/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "write_projections", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:write_projections", + "decorators": [], + "kind": "function", + "name": "write_projections", + "parent_identity": null, + "qualified_name": "write_projections", + "signature": "def write_projections(out_dir: Path, projections: dict[str, str], *, prune: bool=False) -> list[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1095, + "span": { + "end": { + "byte": 39088, + "column": 18, + "line": 1095 + }, + "start": { + "byte": 37340, + "column": 0, + "line": 1053 + } + }, + "start_line": 1053 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/write_projections", + "identity": "write_projections", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/write_projections/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/module_projection.py::function:write_projections", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Atomically write projections, optionally pruning a complete output set.", + "text": "Atomically write projections, optionally pruning a complete output set." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3f106f79a5856b8ef14d3aebd0fc295df29c5d52f01f75550032e2c08979fd9", + "file": "msdmd/module_projection.py", + "location": { + "end_line": 1059, + "span": { + "end": { + "byte": 37545, + "column": 81, + "line": 1059 + }, + "start": { + "byte": 37468, + "column": 4, + "line": 1059 + } + }, + "start_line": 1059 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/module_projection.py#subject/symbol/write_projections", + "identity": "write_projections", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "83:3" + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A220-220/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "83:3" + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 220, + "start_line": 220 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "15:3" + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A220-220/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "15:3" + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 220, + "start_line": 220 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "195:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A220-220/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "195:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 220, + "start_line": 220 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=195:14 imports_exports=15:3 calls_definitions=83:3" + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 73, + "column": 73, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=195:14 imports_exports=15:3 calls_definitions=83:3" + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 220, + "span": { + "end": { + "byte": 14740, + "column": 73, + "line": 220 + }, + "start": { + "byte": 14667, + "column": 0, + "line": 220 + } + }, + "start_line": 220 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::<module>", + "description": "Usage: registry calls read_python/read_typescript with bounded bytes and context.\nPython delegates symbol/comment attachment to module_projection. The TypeScript\ncompiler is a library worker, not the inspected program. Neither reader resolves\nimports, loads target configuration, or establishes runtime behavior.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Syntax-aware code readers for the unified collection.", + "text": "Syntax-aware code readers for the unified collection.\n\nUsage: registry calls read_python/read_typescript with bounded bytes and context.\nPython delegates symbol/comment attachment to module_projection. The TypeScript\ncompiler is a library worker, not the inspected program. Neither reader resolves\nimports, loads target configuration, or establishes runtime behavior.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 8, + "span": { + "end": { + "byte": 448, + "column": 3, + "line": 8 + }, + "start": { + "byte": 74, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "ast:ast:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "ast", + "name": "ast" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.module_projection:project_python_bytes:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.module_projection", + "name": "project_python_bytes" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.module_projection:_byte_line_reader:11", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.module_projection", + "name": "_byte_line_reader" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/12", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tokenize:tokenize:12", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tokenize", + "name": "tokenize" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:6", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:7", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/module/msdmd%2Fnative_code.py", + "identity": "msdmd/native_code.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python.location/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_python.location", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::function:read_python.location", + "decorators": [], + "kind": "function", + "name": "location", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::function:read_python", + "qualified_name": "read_python.location", + "signature": "def location(record: dict) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 46, + "span": { + "end": { + "byte": 1970, + "column": 85, + "line": 46 + }, + "start": { + "byte": 1812, + "column": 4, + "line": 44 + } + }, + "start_line": 44 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python.location", + "identity": "read_python.location", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::function:read_python", + "metadata_kind": "comment", + "text": "Only duplicate qualified names need the attachment reader's signature suffix." + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 36, + "span": { + "end": { + "byte": 1488, + "column": 83, + "line": 36 + }, + "start": { + "byte": 1409, + "column": 4, + "line": 36 + } + }, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "identity": "read_python", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::function:read_python", + "metadata_kind": "comment", + "text": "Stable semantic pointer; exact byte/line span is provenance, not identity." + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 62, + "span": { + "end": { + "byte": 3165, + "column": 88, + "line": 62 + }, + "start": { + "byte": 3089, + "column": 12, + "line": 62 + } + }, + "start_line": 62 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "identity": "read_python", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::function:read_python", + "metadata_kind": "comment", + "text": "A parser rejection must not discard the source-owned docstring." + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 86, + "span": { + "end": { + "byte": 4659, + "column": 81, + "line": 86 + }, + "start": { + "byte": 4594, + "column": 16, + "line": 86 + } + }, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "identity": "read_python", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::function:read_python", + "metadata_kind": "comment", + "text": "A literal initializer is not a complete export set after another write,\nmutation, conditional assignment, or escape through an alias/call.\nOnly one simple module-level literal assignment with no subsequent uses\nearns static standing. Other syntax remains visible without execution." + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 132, + "span": { + "end": { + "byte": 8145, + "column": 76, + "line": 132 + }, + "start": { + "byte": 7844, + "column": 4, + "line": 129 + } + }, + "start_line": 129 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "identity": "read_python", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_python", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::function:read_python", + "decorators": [], + "kind": "function", + "name": "read_python", + "parent_identity": null, + "qualified_name": "read_python", + "signature": "def read_python(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 158, + "span": { + "end": { + "byte": 9848, + "column": 36, + "line": 158 + }, + "start": { + "byte": 715, + "column": 0, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "identity": "read_python", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_fact:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_fact" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "identity": "read_python", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_diagnostic:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_diagnostic" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "identity": "read_python", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_subject_address:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_subject_address" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "identity": "read_python", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_edge:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_edge" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "identity": "read_python", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "docstring_parser:docstring_parser:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "docstring_parser", + "name": "docstring_parser" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 76, + "start_line": 76 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_python", + "identity": "read_python", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::function:read_typescript", + "metadata_kind": "comment", + "text": "Package resolution is rooted at the trusted helper, never the inspected repo." + } + }, + "origin": "native", + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 166, + "span": { + "end": { + "byte": 10305, + "column": 83, + "line": 166 + }, + "start": { + "byte": 10226, + "column": 4, + "line": 166 + } + }, + "start_line": 166 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript", + "identity": "read_typescript", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_typescript", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/native_code.py::function:read_typescript", + "decorators": [], + "kind": "function", + "name": "read_typescript", + "parent_identity": null, + "qualified_name": "read_typescript", + "signature": "def read_typescript(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 219, + "span": { + "end": { + "byte": 14666, + "column": 36, + "line": 219 + }, + "start": { + "byte": 9851, + "column": 0, + "line": 161 + } + }, + "start_line": 161 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript", + "identity": "read_typescript", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_fact:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_fact" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 162, + "start_line": 162 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript", + "identity": "read_typescript", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_diagnostic:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_diagnostic" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 162, + "start_line": 162 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript", + "identity": "read_typescript", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_edge:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_edge" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 162, + "start_line": 162 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript", + "identity": "read_typescript", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_subject_address:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_subject_address" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8c991398fc409634929ed70001783372a34fa1de52a0d3a8169cda478d3a92ab", + "file": "msdmd/native_code.py", + "location": { + "end_line": 162, + "start_line": 162 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/native_code.py#subject/symbol/read_typescript", + "identity": "read_typescript", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/package-lock.json#subject/package/./fact/locked-package/%2Fpackages%2F/", + "convention": { + "dialect": "npm.lockfile", + "namespace": "npm.lockfile", + "version": "3" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "locked-package", + "native": { + "id": "", + "value": { + "dependencies": { + "typescript": "5.8.3" + }, + "name": "msdmd-native-reader-runtime" + } + }, + "origin": "native", + "source": { + "content_sha256": "aaa0e822e8c9ec33c97b31a1a72622d427814b29ce21d9884514cc009ed60e67", + "file": "msdmd/package-lock.json", + "location": { + "pointer": "/packages/" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/package-lock.json#subject/package/.", + "identity": ".", + "scope": "package" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/package-lock.json#subject/package/msdmd%2Fpackage-lock.json/fact/lockfile/lines%3A%3F-%3F", + "convention": { + "dialect": "npm.lockfile", + "namespace": "npm.lockfile", + "version": "3" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "lockfile", + "native": { + "id": null, + "value": { + "lockfileVersion": 3, + "name": "msdmd-native-reader-runtime", + "packages": { + "": { + "dependencies": { + "typescript": "5.8.3" + }, + "name": "msdmd-native-reader-runtime" + }, + "node_modules/typescript": { + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + }, + "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", + "license": "Apache-2.0", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", + "version": "5.8.3" + } + }, + "requires": true + } + }, + "origin": "native", + "source": { + "content_sha256": "aaa0e822e8c9ec33c97b31a1a72622d427814b29ce21d9884514cc009ed60e67", + "file": "msdmd/package-lock.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/package-lock.json#subject/package/msdmd%2Fpackage-lock.json", + "identity": "msdmd/package-lock.json", + "scope": "package" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/package-lock.json#subject/package/node_modules%2Ftypescript/fact/locked-package/%2Fpackages%2Fnode_modules~1typescript/node_modules%2Ftypescript", + "convention": { + "dialect": "npm.lockfile", + "namespace": "npm.lockfile", + "version": "3" + }, + "extraction": { + "configuration_sha256": "e7de15ce3692d1ddfd1f622e067bba90902fe9724f3f01df44502e491a8b8eb6", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "locked-package", + "native": { + "id": "node_modules/typescript", + "value": { + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + }, + "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", + "license": "Apache-2.0", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", + "version": "5.8.3" + } + }, + "origin": "native", + "source": { + "content_sha256": "aaa0e822e8c9ec33c97b31a1a72622d427814b29ce21d9884514cc009ed60e67", + "file": "msdmd/package-lock.json", + "location": { + "pointer": "/packages/node_modules~1typescript" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/package-lock.json#subject/package/node_modules%2Ftypescript", + "identity": "node_modules/typescript", + "scope": "package" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/package.json#subject/document/msdmd%2Fpackage.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "npm.package-json", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "dependencies": { + "typescript": "5.8.3" + }, + "description": "Pinned syntax-only TypeScript parser for MSDMD; never loads inspected projects", + "name": "msdmd-native-reader-runtime", + "private": true + } + }, + "origin": "native", + "source": { + "content_sha256": "4860ed8625d09f6da8d0bf7f5977a786f195f660b0e93ac31e2560ad1bbe86ba", + "file": "msdmd/package.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/package.json#subject/document/msdmd%2Fpackage.json", + "identity": "msdmd/package.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/package.json#subject/package/msdmd-native-reader-runtime/fact/dependency/%2Fdependencies%2Ftypescript/typescript", + "convention": { + "dialect": "json", + "namespace": "npm.package-json", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typescript", + "value": { + "class": "runtime", + "constraint": "5.8.3", + "name": "typescript" + } + }, + "origin": "native", + "projection": { + "loss": "none", + "mapping_version": "npm-dependencies@1", + "relation": "depends_on" + }, + "source": { + "content_sha256": "4860ed8625d09f6da8d0bf7f5977a786f195f660b0e93ac31e2560ad1bbe86ba", + "file": "msdmd/package.json", + "location": { + "pointer": "/dependencies/typescript" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/package.json#subject/package/msdmd-native-reader-runtime", + "identity": "msdmd-native-reader-runtime", + "scope": "package" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "fd3de624f4a8d40985ee41128ae1331059795407b78b0fd675ebb3265d9e336a", + "file": "msdmd/parsers/__init__.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A7-7/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "fd3de624f4a8d40985ee41128ae1331059795407b78b0fd675ebb3265d9e336a", + "file": "msdmd/parsers/__init__.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "fd3de624f4a8d40985ee41128ae1331059795407b78b0fd675ebb3265d9e336a", + "file": "msdmd/parsers/__init__.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A7-7/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "fd3de624f4a8d40985ee41128ae1331059795407b78b0fd675ebb3265d9e336a", + "file": "msdmd/parsers/__init__.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "0:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "fd3de624f4a8d40985ee41128ae1331059795407b78b0fd675ebb3265d9e336a", + "file": "msdmd/parsers/__init__.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A7-7/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "0:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "fd3de624f4a8d40985ee41128ae1331059795407b78b0fd675ebb3265d9e336a", + "file": "msdmd/parsers/__init__.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/module/msdmd%2Fparsers%2F__init__.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/__init__.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=0:4 imports_exports=0:0 calls_definitions=0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "fd3de624f4a8d40985ee41128ae1331059795407b78b0fd675ebb3265d9e336a", + "file": "msdmd/parsers/__init__.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 68, + "column": 68, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/module/msdmd%2Fparsers%2F__init__.py", + "identity": "msdmd/parsers/__init__.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/module/msdmd%2Fparsers%2F__init__.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/__init__.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=0:4 imports_exports=0:0 calls_definitions=0:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "fd3de624f4a8d40985ee41128ae1331059795407b78b0fd675ebb3265d9e336a", + "file": "msdmd/parsers/__init__.py", + "location": { + "end_line": 7, + "span": { + "end": { + "byte": 303, + "column": 68, + "line": 7 + }, + "start": { + "byte": 235, + "column": 0, + "line": 7 + } + }, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/module/msdmd%2Fparsers%2F__init__.py", + "identity": "msdmd/parsers/__init__.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/module/msdmd%2Fparsers%2F__init__.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/__init__.py::<module>", + "description": "`universal` is the canonical Python implementation of the parser\ncontract defined in ``msdmd/SKILL.md``. Pure stdlib; copy anywhere.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "msdmd reference parsers.", + "text": "msdmd reference parsers.\n\n`universal` is the canonical Python implementation of the parser\ncontract defined in ``msdmd/SKILL.md``. Pure stdlib; copy anywhere.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "fd3de624f4a8d40985ee41128ae1331059795407b78b0fd675ebb3265d9e336a", + "file": "msdmd/parsers/__init__.py", + "location": { + "end_line": 6, + "span": { + "end": { + "byte": 234, + "column": 3, + "line": 6 + }, + "start": { + "byte": 69, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/__init__.py#subject/module/msdmd%2Fparsers%2F__init__.py", + "identity": "msdmd/parsers/__init__.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "55:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A279-279/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "55:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 279, + "start_line": 279 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "4:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A279-279/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "4:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 279, + "start_line": 279 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "161:80" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A279-279/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "161:80" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 279, + "start_line": 279 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=161:80 imports_exports=4:7 calls_definitions=55:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 73, + "column": 73, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "identity": "msdmd/parsers/universal.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: msdmd_python_reference_parser\n module_name: universal\n module_kind: instrument\n summary: parses canonical line-comment metadata without executing inspected source\n owner: The Interdependency skill-lib\n public_surface: COMMENT_MARKERS, RATIO_IDS, marker_for, parse_text, parse_file, walk_tree, parse_ratios, parse_ratios_file, ratios_placement\n internal_surface: marker and block matching helpers\n auth_boundary: none\n storage_boundary: read\n network_boundary: none\n user_data_boundary: read\n admin_only: false\n tests: tests/test_universal_parser.py\n rollout: exact-pinned reference parser propagation\n rollback: restore a previously accepted exact parser identity\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 18, + "span": { + "end": { + "byte": 835, + "column": 26, + "line": 18 + }, + "start": { + "byte": 74, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "identity": "msdmd/parsers/universal.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CONTRACTS ===\nid: msdmd_python_parser_preserves_field_names\n given: a valid metadata entry uses lowercase snake-case field names containing digits\n then: parsed entries retain those field names and string values without executing the inspected source\n class: evidence\n=== END CONTRACTS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 24, + "span": { + "end": { + "byte": 1144, + "column": 23, + "line": 24 + }, + "start": { + "byte": 836, + "column": 0, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "identity": "msdmd/parsers/universal.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::<module>", + "metadata_kind": "comment", + "text": "extension → line-comment marker. Keep this registry entry-for-entry equivalent\nto universal.ts; tests fail if either parser gains or loses an extension alone." + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 60, + "span": { + "end": { + "byte": 2743, + "column": 81, + "line": 60 + }, + "start": { + "byte": 2579, + "column": 0, + "line": 59 + } + }, + "start_line": 59 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "identity": "msdmd/parsers/universal.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::<module>", + "metadata_kind": "comment", + "text": "--- RATIOS single-line declaration (msdmd extension) --------------------\nUnlike every other declaration, RATIOS is not fenced. It is a single\ncomment line carrying the three canonical ratios at the opening source\nboundary and last non-blank line. A valid line-1 shebang moves the opening\nboundary to literal line 2:\n <marker> ratios: loc_comments=N:M imports_exports=N:M calls_definitions=N:M" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 213, + "span": { + "end": { + "byte": 8463, + "column": 81, + "line": 213 + }, + "start": { + "byte": 8055, + "column": 0, + "line": 208 + } + }, + "start_line": 208 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "identity": "msdmd/parsers/universal.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py/fact/comment/5", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=161:80 imports_exports=4:7 calls_definitions=55:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 279, + "span": { + "end": { + "byte": 10987, + "column": 73, + "line": 279 + }, + "start": { + "byte": 10914, + "column": 0, + "line": 279 + } + }, + "start_line": 279 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "identity": "msdmd/parsers/universal.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::<module>", + "description": "Implements the parser contract from ``msdmd/SKILL.md``: extracts every\n``# === <BLOCK_NAME> ===`` … ``# === END <BLOCK_NAME> ===`` block from\na source file and returns its entries as flat dicts.\n\nComment marker is auto-detected by file extension. The block syntax\nitself is identical across languages; only the per-line marker changes.\n``COMMENT_MARKERS`` is public so runners can distinguish parser support\nfrom their narrower language-specific execution or metric coverage.\n\nPublic API:\n\n parse_text(text, block_name, marker=\"#\") -> list[dict]\n parse_file(path, block_name) -> list[dict]\n walk_tree(root, block_name, *, skip=None, extensions=None) -> tuple[annotated, untested]\n\nRATIOS is the one msdmd declaration that is *not* a fenced block — it is a\nsingle comment line carried on a file's opening and closing source boundaries.\nA valid interpreter shebang owns literal line 1, so the opening RATIOS line is\nliteral line 2 in that case. The reader lives here as a sanctioned extension:\n\n parse_ratios(text, marker=\"#\") -> list[dict]\n parse_ratios_file(path) -> list[dict]\n ratios_placement(text, marker=\"#\") -> tuple[opening_ok, closing_ok]\n\nThis module has zero non-stdlib dependencies and is safe to copy\nverbatim into any project that wants msdmd support.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Universal msdmd parser — pure stdlib.", + "text": "Universal msdmd parser — pure stdlib.\n\nImplements the parser contract from ``msdmd/SKILL.md``: extracts every\n``# === <BLOCK_NAME> ===`` … ``# === END <BLOCK_NAME> ===`` block from\na source file and returns its entries as flat dicts.\n\nComment marker is auto-detected by file extension. The block syntax\nitself is identical across languages; only the per-line marker changes.\n``COMMENT_MARKERS`` is public so runners can distinguish parser support\nfrom their narrower language-specific execution or metric coverage.\n\nPublic API:\n\n parse_text(text, block_name, marker=\"#\") -> list[dict]\n parse_file(path, block_name) -> list[dict]\n walk_tree(root, block_name, *, skip=None, extensions=None) -> tuple[annotated, untested]\n\nRATIOS is the one msdmd declaration that is *not* a fenced block — it is a\nsingle comment line carried on a file's opening and closing source boundaries.\nA valid interpreter shebang owns literal line 1, so the opening RATIOS line is\nliteral line 2 in that case. The reader lives here as a sanctioned extension:\n\n parse_ratios(text, marker=\"#\") -> list[dict]\n parse_ratios_file(path) -> list[dict]\n ratios_placement(text, marker=\"#\") -> tuple[opening_ok, closing_ok]\n\nThis module has zero non-stdlib dependencies and is safe to copy\nverbatim into any project that wants msdmd support.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 53, + "span": { + "end": { + "byte": 2479, + "column": 3, + "line": 53 + }, + "start": { + "byte": 1145, + "column": 0, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "identity": "msdmd/parsers/universal.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 54, + "start_line": 54 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "identity": "msdmd/parsers/universal.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 55, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "identity": "msdmd/parsers/universal.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 56, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "identity": "msdmd/parsers/universal.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterable:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 57, + "start_line": 57 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/module/msdmd%2Fparsers%2Funiversal.py", + "identity": "msdmd/parsers/universal.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/_block_regex/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_block_regex", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:_block_regex", + "decorators": [], + "kind": "function", + "name": "_block_regex", + "parent_identity": null, + "qualified_name": "_block_regex", + "signature": "def _block_regex(block_name: str, marker: str) -> re.Pattern[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 112, + "span": { + "end": { + "byte": 4770, + "column": 5, + "line": 112 + }, + "start": { + "byte": 4505, + "column": 0, + "line": 106 + } + }, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/_block_regex", + "identity": "_block_regex", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/_ratios_line_re/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_ratios_line_re", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:_ratios_line_re", + "decorators": [], + "kind": "function", + "name": "_ratios_line_re", + "parent_identity": null, + "qualified_name": "_ratios_line_re", + "signature": "def _ratios_line_re(marker: str) -> re.Pattern[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 219, + "span": { + "end": { + "byte": 8738, + "column": 77, + "line": 219 + }, + "start": { + "byte": 8608, + "column": 0, + "line": 218 + } + }, + "start_line": 218 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/_ratios_line_re", + "identity": "_ratios_line_re", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/marker_for/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "marker_for", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:marker_for", + "decorators": [], + "kind": "function", + "name": "marker_for", + "parent_identity": null, + "qualified_name": "marker_for", + "signature": "def marker_for(path: Path) -> str | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 103, + "span": { + "end": { + "byte": 4502, + "column": 51, + "line": 103 + }, + "start": { + "byte": 4332, + "column": 0, + "line": 101 + } + }, + "start_line": 101 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/marker_for", + "identity": "marker_for", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/marker_for/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:marker_for", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return the comment marker for a file path, or None if unsupported.", + "text": "Return the comment marker for a file path, or None if unsupported." + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 102, + "span": { + "end": { + "byte": 4450, + "column": 76, + "line": 102 + }, + "start": { + "byte": 4378, + "column": 4, + "line": 102 + } + }, + "start_line": 102 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/marker_for", + "identity": "marker_for", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_file/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_file", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:parse_file", + "decorators": [], + "kind": "function", + "name": "parse_file", + "parent_identity": null, + "qualified_name": "parse_file", + "signature": "def parse_file(path: Path, block_name: str) -> list[dict]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 158, + "span": { + "end": { + "byte": 6455, + "column": 17, + "line": 158 + }, + "start": { + "byte": 6049, + "column": 0, + "line": 149 + } + }, + "start_line": 149 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_file", + "identity": "parse_file", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_file/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:parse_file", + "description": "known comment marker or if the file can't be read.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Parse a single file. Returns [] if the file's extension has no", + "text": "Parse a single file. Returns [] if the file's extension has no\n known comment marker or if the file can't be read." + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 151, + "span": { + "end": { + "byte": 6235, + "column": 57, + "line": 151 + }, + "start": { + "byte": 6112, + "column": 4, + "line": 150 + } + }, + "start_line": 150 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_file", + "identity": "parse_file", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_ratios/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_ratios", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:parse_ratios", + "decorators": [], + "kind": "function", + "name": "parse_ratios", + "parent_identity": null, + "qualified_name": "parse_ratios", + "signature": "def parse_ratios(text: str, marker: str='#') -> list[dict]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 239, + "span": { + "end": { + "byte": 9549, + "column": 14, + "line": 239 + }, + "start": { + "byte": 8741, + "column": 0, + "line": 222 + } + }, + "start_line": 222 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_ratios", + "identity": "parse_ratios", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_ratios/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:parse_ratios", + "description": "RATIOS is not a fenced block: it is one comment line of the form\n``<marker> ratios: loc_comments=N:M imports_exports=N:M calls_definitions=N:M``\nplaced at the file's opening and closing source boundaries. Returns one\nflat ``{\"id\", \"value\"}`` dict per (declaration line x ratio token) so a\ndrift gate can verify every occurrence.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Read single-line RATIOS declarations from ``text``.", + "text": "Read single-line RATIOS declarations from ``text``.\n\n RATIOS is not a fenced block: it is one comment line of the form\n ``<marker> ratios: loc_comments=N:M imports_exports=N:M calls_definitions=N:M``\n placed at the file's opening and closing source boundaries. Returns one\n flat ``{\"id\", \"value\"}`` dict per (declaration line x ratio token) so a\n drift gate can verify every occurrence.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 230, + "span": { + "end": { + "byte": 9219, + "column": 7, + "line": 230 + }, + "start": { + "byte": 8807, + "column": 4, + "line": 223 + } + }, + "start_line": 223 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_ratios", + "identity": "parse_ratios", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_ratios_file/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_ratios_file", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:parse_ratios_file", + "decorators": [], + "kind": "function", + "name": "parse_ratios_file", + "parent_identity": null, + "qualified_name": "parse_ratios_file", + "signature": "def parse_ratios_file(path: Path) -> list[dict]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 250, + "span": { + "end": { + "byte": 9890, + "column": 17, + "line": 250 + }, + "start": { + "byte": 9552, + "column": 0, + "line": 242 + } + }, + "start_line": 242 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_ratios_file", + "identity": "parse_ratios_file", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_ratios_file/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:parse_ratios_file", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "``parse_ratios`` for a file path (marker auto-detected); [] on error.", + "text": "``parse_ratios`` for a file path (marker auto-detected); [] on error." + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 243, + "span": { + "end": { + "byte": 9680, + "column": 79, + "line": 243 + }, + "start": { + "byte": 9605, + "column": 4, + "line": 243 + } + }, + "start_line": 243 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_ratios_file", + "identity": "parse_ratios_file", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parse_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:parse_text", + "decorators": [], + "kind": "function", + "name": "parse_text", + "parent_identity": null, + "qualified_name": "parse_text", + "signature": "def parse_text(text: str, block_name: str, marker: str='#') -> list[dict]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 146, + "span": { + "end": { + "byte": 6046, + "column": 18, + "line": 146 + }, + "start": { + "byte": 4773, + "column": 0, + "line": 115 + } + }, + "start_line": 115 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_text", + "identity": "parse_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_text/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:parse_text", + "description": "Entries are flat ``dict[str, str]`` keyed by field name. The first\nline of an entry must be ``id: <value>``; subsequent lines until\nthe next ``id:`` (or block end) carry indented ``<key>: <value>``\npairs.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Extract every entry from every matching block in ``text``.", + "text": "Extract every entry from every matching block in ``text``.\n\n Entries are flat ``dict[str, str]`` keyed by field name. The first\n line of an entry must be ``id: <value>``; subsequent lines until\n the next ``id:`` (or block end) carry indented ``<key>: <value>``\n pairs.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 122, + "span": { + "end": { + "byte": 5145, + "column": 7, + "line": 122 + }, + "start": { + "byte": 4854, + "column": 4, + "line": 116 + } + }, + "start_line": 116 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/parse_text", + "identity": "parse_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/ratios_placement/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ratios_placement", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:ratios_placement", + "decorators": [], + "kind": "function", + "name": "ratios_placement", + "parent_identity": null, + "qualified_name": "ratios_placement", + "signature": "def ratios_placement(text: str, marker: str='#') -> tuple[bool, bool]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 278, + "span": { + "end": { + "byte": 10913, + "column": 32, + "line": 278 + }, + "start": { + "byte": 9893, + "column": 0, + "line": 253 + } + }, + "start_line": 253 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/ratios_placement", + "identity": "ratios_placement", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/ratios_placement/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:ratios_placement", + "description": "A non-empty ``#!`` interpreter directive may occupy literal line 1. It is\nthe only accepted preamble and RATIOS must immediately follow it.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return ``(opening_ratios_ok, closing_ratios_ok)``.", + "text": "Return ``(opening_ratios_ok, closing_ratios_ok)``.\n\n A non-empty ``#!`` interpreter directive may occupy literal line 1. It is\n the only accepted preamble and RATIOS must immediately follow it.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 258, + "span": { + "end": { + "byte": 10180, + "column": 7, + "line": 258 + }, + "start": { + "byte": 9970, + "column": 4, + "line": 254 + } + }, + "start_line": 254 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/ratios_placement", + "identity": "ratios_placement", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/walk_tree.iter_source_files/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "walk_tree.iter_source_files", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:walk_tree.iter_source_files", + "decorators": [], + "kind": "function", + "name": "iter_source_files", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:walk_tree", + "qualified_name": "walk_tree.iter_source_files", + "signature": "def iter_source_files(path: Path) -> Iterable[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 195, + "span": { + "end": { + "byte": 7738, + "column": 27, + "line": 195 + }, + "start": { + "byte": 7247, + "column": 4, + "line": 182 + } + }, + "start_line": 182 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/walk_tree.iter_source_files", + "identity": "walk_tree.iter_source_files", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/walk_tree/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "walk_tree", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:walk_tree", + "decorators": [], + "kind": "function", + "name": "walk_tree", + "parent_identity": null, + "qualified_name": "walk_tree", + "signature": "def walk_tree(root: Path, block_name: str, *, skip: Iterable[str] | None=None, extensions: Iterable[str] | None=None) -> tuple[list[tuple[Path, list[dict]]], list[Path]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 205, + "span": { + "end": { + "byte": 8052, + "column": 30, + "line": 205 + }, + "start": { + "byte": 6458, + "column": 0, + "line": 161 + } + }, + "start_line": 161 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/walk_tree", + "identity": "walk_tree", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/walk_tree/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/parsers/universal.py::function:walk_tree", + "description": "``annotated`` is a list of ``(path, entries)`` for every file that\ncontains at least one entry of ``block_name``. ``untested`` is every\nother source file (still filtered by extension and skip-dirs) so\ncoverage gaps remain observable.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Walk ``root`` and partition source files into (annotated, untested).", + "text": "Walk ``root`` and partition source files into (annotated, untested).\n\n ``annotated`` is a list of ``(path, entries)`` for every file that\n contains at least one entry of ``block_name``. ``untested`` is every\n other source file (still filtered by extension and skip-dirs) so\n coverage gaps remain observable.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "ed280f3fe8f4a59a7c82fe32c88a63a98cfc42c07e32c273c72c89747497f76c", + "file": "msdmd/parsers/universal.py", + "location": { + "end_line": 174, + "span": { + "end": { + "byte": 6990, + "column": 7, + "line": 174 + }, + "start": { + "byte": 6660, + "column": 4, + "line": 168 + } + }, + "start_line": 168 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.py#subject/symbol/walk_tree", + "identity": "walk_tree", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A257-257/calls_definitions", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 257, + "start_line": 257 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A257-257/imports_exports", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 257, + "start_line": 257 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A257-257/loc_comments", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 257, + "start_line": 257 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A1-1/0", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "0", + "value": { + "attachment": "module-trivia", + "end_line": 1, + "identity": null, + "owner": null, + "start_line": 1, + "text": "// ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A10-10/9", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "9", + "value": { + "attachment": "module-trivia", + "end_line": 10, + "identity": null, + "owner": null, + "start_line": 10, + "text": "// auth_boundary: none" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A11-11/10", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "10", + "value": { + "attachment": "module-trivia", + "end_line": 11, + "identity": null, + "owner": null, + "start_line": 11, + "text": "// storage_boundary: read" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A12-12/11", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "11", + "value": { + "attachment": "module-trivia", + "end_line": 12, + "identity": null, + "owner": null, + "start_line": 12, + "text": "// network_boundary: none" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A13-13/12", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "12", + "value": { + "attachment": "module-trivia", + "end_line": 13, + "identity": null, + "owner": null, + "start_line": 13, + "text": "// user_data_boundary: read" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A14-14/13", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "13", + "value": { + "attachment": "module-trivia", + "end_line": 14, + "identity": null, + "owner": null, + "start_line": 14, + "text": "// admin_only: false" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A15-15/14", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "14", + "value": { + "attachment": "module-trivia", + "end_line": 15, + "identity": null, + "owner": null, + "start_line": 15, + "text": "// tests: tests/test_universal_parser.py::test_typescript_parser_field_contract" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A16-16/15", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "15", + "value": { + "attachment": "module-trivia", + "end_line": 16, + "identity": null, + "owner": null, + "start_line": 16, + "text": "// rollout: exact-pinned reference parser propagation" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A17-17/16", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "16", + "value": { + "attachment": "module-trivia", + "end_line": 17, + "identity": null, + "owner": null, + "start_line": 17, + "text": "// rollback: restore a previously accepted exact parser identity" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A18-18/17", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "17", + "value": { + "attachment": "module-trivia", + "end_line": 18, + "identity": null, + "owner": null, + "start_line": 18, + "text": "// === END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A19-19/18", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "18", + "value": { + "attachment": "module-trivia", + "end_line": 19, + "identity": null, + "owner": null, + "start_line": 19, + "text": "// === CONTRACTS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A197-197/27", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "27", + "value": { + "attachment": "module-trivia", + "end_line": 197, + "identity": null, + "owner": null, + "start_line": 197, + "text": "// --- RATIOS single-line declaration (msdmd extension) --------------------" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 197, + "start_line": 197 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A198-198/28", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "28", + "value": { + "attachment": "module-trivia", + "end_line": 198, + "identity": null, + "owner": null, + "start_line": 198, + "text": "// Unlike every other declaration, RATIOS is not fenced. It is a single" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 198, + "start_line": 198 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A199-199/29", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "29", + "value": { + "attachment": "module-trivia", + "end_line": 199, + "identity": null, + "owner": null, + "start_line": 199, + "text": "// comment line carrying the three canonical ratios at the opening source" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 199, + "start_line": 199 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A2-2/1", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "1", + "value": { + "attachment": "module-trivia", + "end_line": 2, + "identity": null, + "owner": null, + "start_line": 2, + "text": "// === MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A20-20/19", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "19", + "value": { + "attachment": "module-trivia", + "end_line": 20, + "identity": null, + "owner": null, + "start_line": 20, + "text": "// id: msdmd_typescript_parser_preserves_field_names" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A200-200/30", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "30", + "value": { + "attachment": "module-trivia", + "end_line": 200, + "identity": null, + "owner": null, + "start_line": 200, + "text": "// boundary and last non-blank line. A valid line-1 shebang moves the opening" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 200, + "start_line": 200 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A201-201/31", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "31", + "value": { + "attachment": "module-trivia", + "end_line": 201, + "identity": null, + "owner": null, + "start_line": 201, + "text": "// boundary to literal line 2:" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 201, + "start_line": 201 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A202-202/32", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "32", + "value": { + "attachment": "module-trivia", + "end_line": 202, + "identity": null, + "owner": null, + "start_line": 202, + "text": "// <marker> ratios: loc_comments=N:M imports_exports=N:M calls_definitions=N:M" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 202, + "start_line": 202 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A21-21/20", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "20", + "value": { + "attachment": "module-trivia", + "end_line": 21, + "identity": null, + "owner": null, + "start_line": 21, + "text": "// given: a valid metadata entry uses lowercase snake-case field names containing digits" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A22-22/21", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "21", + "value": { + "attachment": "module-trivia", + "end_line": 22, + "identity": null, + "owner": null, + "start_line": 22, + "text": "// then: parsed entries retain those field names and string values without executing the inspected source" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A23-23/22", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "22", + "value": { + "attachment": "module-trivia", + "end_line": 23, + "identity": null, + "owner": null, + "start_line": 23, + "text": "// class: evidence" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 23, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A24-24/23", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "23", + "value": { + "attachment": "module-trivia", + "end_line": 24, + "identity": null, + "owner": null, + "start_line": 24, + "text": "// === END CONTRACTS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 24, + "start_line": 24 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A25-45/24", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "24", + "value": { + "attachment": "module-trivia", + "end_line": 45, + "identity": null, + "owner": null, + "start_line": 25, + "text": "/**\n * Universal msdmd parser — pure Node stdlib (fs, path).\n *\n * TypeScript counterpart to parsers/universal.py. Implements the\n * parser contract from msdmd/SKILL.md: extracts every\n * `// === <BLOCK_NAME> ===` … `// === END <BLOCK_NAME> ===` block\n * from a source file and returns its entries as flat objects.\n *\n * Comment marker auto-detected by file extension. The block syntax\n * itself is identical across languages; only the per-line marker\n * changes. COMMENT_MARKERS is public so runners can keep their narrower\n * language-specific execution or metric coverage separate.\n *\n * RATIOS is the one msdmd declaration that is not a fenced block — it is a\n * single comment line on a file's opening and closing source boundaries. A\n * valid interpreter shebang owns literal line 1, moving opening RATIOS to\n * literal line 2. Its reader lives here as a sanctioned extension.\n *\n * Zero non-stdlib dependencies. Safe to copy verbatim into any\n * Node/Deno/Bun project that wants msdmd support.\n */" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 45, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A257-257/33", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "33", + "value": { + "attachment": "module-trivia", + "end_line": 257, + "identity": null, + "owner": null, + "start_line": 257, + "text": "// ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 257, + "start_line": 257 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A3-3/2", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "2", + "value": { + "attachment": "module-trivia", + "end_line": 3, + "identity": null, + "owner": null, + "start_line": 3, + "text": "// id: msdmd_typescript_reference_parser" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A4-4/3", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "3", + "value": { + "attachment": "module-trivia", + "end_line": 4, + "identity": null, + "owner": null, + "start_line": 4, + "text": "// module_name: universal" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A5-5/4", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "4", + "value": { + "attachment": "module-trivia", + "end_line": 5, + "identity": null, + "owner": null, + "start_line": 5, + "text": "// module_kind: instrument" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A51-51/25", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "25", + "value": { + "attachment": "module-trivia", + "end_line": 51, + "identity": null, + "owner": null, + "start_line": 51, + "text": "// Keep this registry entry-for-entry equivalent to universal.py; tests fail if" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 51, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A52-52/26", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "26", + "value": { + "attachment": "module-trivia", + "end_line": 52, + "identity": null, + "owner": null, + "start_line": 52, + "text": "// either parser gains or loses an extension alone." + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 52, + "start_line": 52 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A6-6/5", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "5", + "value": { + "attachment": "module-trivia", + "end_line": 6, + "identity": null, + "owner": null, + "start_line": 6, + "text": "// summary: parses canonical line-comment metadata without executing inspected source" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A7-7/6", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "6", + "value": { + "attachment": "module-trivia", + "end_line": 7, + "identity": null, + "owner": null, + "start_line": 7, + "text": "// owner: The Interdependency skill-lib" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A8-8/7", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "7", + "value": { + "attachment": "module-trivia", + "end_line": 8, + "identity": null, + "owner": null, + "start_line": 8, + "text": "// public_surface: Entry, WalkOptions, COMMENT_MARKERS, RATIO_IDS, markerFor, parseText, parseFile, walkTree, parseRatios, parseRatiosFile, ratiosPlacement" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/comment/lines%3A9-9/8", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "8", + "value": { + "attachment": "module-trivia", + "end_line": 9, + "identity": null, + "owner": null, + "start_line": 9, + "text": "// internal_surface: marker and block matching helpers" + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/dependency/lines%3A46-46/0", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "0", + "value": { + "declaration": "import { readFileSync, statSync, readdirSync } from \"node:fs\";", + "end_line": 46, + "kind": "import", + "module": "node:fs", + "owner": "", + "start_line": 46 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 46, + "start_line": 46 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts/fact/dependency/lines%3A47-47/1", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "1", + "value": { + "declaration": "import { join, extname } from \"node:path\";", + "end_line": 47, + "kind": "import", + "module": "node:path", + "owner": "", + "start_line": 47 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 47, + "start_line": 47 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/module/msdmd%2Fparsers%2Funiversal.ts", + "identity": "msdmd/parsers/universal.ts", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/COMMENT_MARKERS%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "COMMENT_MARKERS", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 84, + "exported": true, + "identity": "COMMENT_MARKERS#0", + "kind": "VariableDeclaration", + "name": "COMMENT_MARKERS", + "parameters": [], + "qualified_name": "COMMENT_MARKERS", + "returns": "Record<string, string>", + "start_line": 53 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 84, + "start_line": 53 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/COMMENT_MARKERS%230", + "identity": "COMMENT_MARKERS#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/DEFAULT_SKIP%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "DEFAULT_SKIP", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 90, + "exported": false, + "identity": "DEFAULT_SKIP#0", + "kind": "VariableDeclaration", + "name": "DEFAULT_SKIP", + "parameters": [], + "qualified_name": "DEFAULT_SKIP", + "returns": null, + "start_line": 86 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 90, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/DEFAULT_SKIP%230", + "identity": "DEFAULT_SKIP#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/Entry%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "Entry", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 49, + "exported": true, + "identity": "Entry#0", + "kind": "TypeAliasDeclaration", + "name": "Entry", + "parameters": [], + "qualified_name": "Entry", + "returns": "Record<string, string>", + "start_line": 49 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 49, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/Entry%230", + "identity": "Entry#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/RATIO_IDS%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "RATIO_IDS", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 203, + "exported": true, + "identity": "RATIO_IDS#0", + "kind": "VariableDeclaration", + "name": "RATIO_IDS", + "parameters": [], + "qualified_name": "RATIO_IDS", + "returns": null, + "start_line": 203 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 203, + "start_line": 203 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/RATIO_IDS%230", + "identity": "RATIO_IDS#0", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/WalkOptions%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "WalkOptions", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 149, + "exported": true, + "identity": "WalkOptions#0", + "kind": "InterfaceDeclaration", + "name": "WalkOptions", + "parameters": [], + "qualified_name": "WalkOptions", + "returns": null, + "start_line": 146 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 149, + "start_line": 146 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/WalkOptions%230", + "identity": "WalkOptions#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/WalkOptions.extensions%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "WalkOptions.extensions", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 148, + "exported": false, + "identity": "WalkOptions.extensions#0", + "kind": "PropertySignature", + "name": "extensions", + "parameters": [], + "qualified_name": "WalkOptions.extensions", + "returns": "Set<string>", + "start_line": 148 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 148, + "start_line": 148 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/WalkOptions.extensions%230", + "identity": "WalkOptions.extensions#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/WalkOptions.skip%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "WalkOptions.skip", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 147, + "exported": false, + "identity": "WalkOptions.skip#0", + "kind": "PropertySignature", + "name": "skip", + "parameters": [], + "qualified_name": "WalkOptions.skip", + "returns": "Set<string>", + "start_line": 147 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 147, + "start_line": 147 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/WalkOptions.skip%230", + "identity": "WalkOptions.skip#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/escapeRegex%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "escapeRegex", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 94, + "exported": false, + "identity": "escapeRegex#0", + "kind": "FunctionDeclaration", + "name": "escapeRegex", + "parameters": [ + { + "default": null, + "name": "s", + "optional": false, + "rest": false, + "type": "string" + } + ], + "qualified_name": "escapeRegex", + "returns": "string", + "start_line": 92 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 94, + "start_line": 92 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/escapeRegex%230", + "identity": "escapeRegex#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/markerFor%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "markerFor", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 98, + "exported": true, + "identity": "markerFor#0", + "kind": "FunctionDeclaration", + "name": "markerFor", + "parameters": [ + { + "default": null, + "name": "path", + "optional": false, + "rest": false, + "type": "string" + } + ], + "qualified_name": "markerFor", + "returns": "string | null", + "start_line": 96 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 98, + "start_line": 96 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/markerFor%230", + "identity": "markerFor#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseFile%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "parseFile", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 144, + "exported": true, + "identity": "parseFile#0", + "kind": "FunctionDeclaration", + "name": "parseFile", + "parameters": [ + { + "default": null, + "name": "path", + "optional": false, + "rest": false, + "type": "string" + }, + { + "default": null, + "name": "blockName", + "optional": false, + "rest": false, + "type": "string" + } + ], + "qualified_name": "parseFile", + "returns": "Entry[]", + "start_line": 136 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 144, + "start_line": 136 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseFile%230", + "identity": "parseFile#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseFile.marker%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseFile.marker", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 137, + "exported": false, + "identity": "parseFile.marker#0", + "kind": "VariableDeclaration", + "name": "marker", + "parameters": [], + "qualified_name": "parseFile.marker", + "returns": null, + "start_line": 137 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 137, + "start_line": 137 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseFile.marker%230", + "identity": "parseFile.marker#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "parseRatios", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 223, + "exported": true, + "identity": "parseRatios#0", + "kind": "FunctionDeclaration", + "name": "parseRatios", + "parameters": [ + { + "default": null, + "name": "text", + "optional": false, + "rest": false, + "type": "string" + }, + { + "default": "\"#\"", + "name": "marker", + "optional": false, + "rest": false, + "type": "string" + } + ], + "qualified_name": "parseRatios", + "returns": "Entry[]", + "start_line": 209 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 223, + "start_line": 209 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios%230", + "identity": "parseRatios#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.lineRe%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseRatios.lineRe", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 210, + "exported": false, + "identity": "parseRatios.lineRe#0", + "kind": "VariableDeclaration", + "name": "lineRe", + "parameters": [], + "qualified_name": "parseRatios.lineRe", + "returns": null, + "start_line": 210 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 210, + "start_line": 210 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.lineRe%230", + "identity": "parseRatios.lineRe#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.lm%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseRatios.lm", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 214, + "exported": false, + "identity": "parseRatios.lm#0", + "kind": "VariableDeclaration", + "name": "lm", + "parameters": [], + "qualified_name": "parseRatios.lm", + "returns": null, + "start_line": 214 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 214, + "start_line": 214 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.lm%230", + "identity": "parseRatios.lm#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.out%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseRatios.out", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 212, + "exported": false, + "identity": "parseRatios.out#0", + "kind": "VariableDeclaration", + "name": "out", + "parameters": [], + "qualified_name": "parseRatios.out", + "returns": "Entry[]", + "start_line": 212 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 212, + "start_line": 212 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.out%230", + "identity": "parseRatios.out#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.raw%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseRatios.raw", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 213, + "exported": false, + "identity": "parseRatios.raw#0", + "kind": "VariableDeclaration", + "name": "raw", + "parameters": [], + "qualified_name": "parseRatios.raw", + "returns": null, + "start_line": 213 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 213, + "start_line": 213 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.raw%230", + "identity": "parseRatios.raw#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.tm%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseRatios.tm", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 216, + "exported": false, + "identity": "parseRatios.tm#0", + "kind": "VariableDeclaration", + "name": "tm", + "parameters": [], + "qualified_name": "parseRatios.tm", + "returns": "RegExpExecArray | null", + "start_line": 216 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 216, + "start_line": 216 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.tm%230", + "identity": "parseRatios.tm#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.tokenRe%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseRatios.tokenRe", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 211, + "exported": false, + "identity": "parseRatios.tokenRe#0", + "kind": "VariableDeclaration", + "name": "tokenRe", + "parameters": [], + "qualified_name": "parseRatios.tokenRe", + "returns": null, + "start_line": 211 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 211, + "start_line": 211 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatios.tokenRe%230", + "identity": "parseRatios.tokenRe#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatiosFile%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "parseRatiosFile", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 233, + "exported": true, + "identity": "parseRatiosFile#0", + "kind": "FunctionDeclaration", + "name": "parseRatiosFile", + "parameters": [ + { + "default": null, + "name": "path", + "optional": false, + "rest": false, + "type": "string" + } + ], + "qualified_name": "parseRatiosFile", + "returns": "Entry[]", + "start_line": 225 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 233, + "start_line": 225 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatiosFile%230", + "identity": "parseRatiosFile#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatiosFile.marker%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseRatiosFile.marker", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 226, + "exported": false, + "identity": "parseRatiosFile.marker#0", + "kind": "VariableDeclaration", + "name": "marker", + "parameters": [], + "qualified_name": "parseRatiosFile.marker", + "returns": null, + "start_line": 226 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 226, + "start_line": 226 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseRatiosFile.marker%230", + "identity": "parseRatiosFile.marker#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "parseText", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 134, + "exported": true, + "identity": "parseText#0", + "kind": "FunctionDeclaration", + "name": "parseText", + "parameters": [ + { + "default": null, + "name": "text", + "optional": false, + "rest": false, + "type": "string" + }, + { + "default": null, + "name": "blockName", + "optional": false, + "rest": false, + "type": "string" + }, + { + "default": "\"#\"", + "name": "marker", + "optional": false, + "rest": false, + "type": "string" + } + ], + "qualified_name": "parseText", + "returns": "Entry[]", + "start_line": 100 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 134, + "start_line": 100 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText%230", + "identity": "parseText#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.blockRe%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.blockRe", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 110, + "exported": false, + "identity": "parseText.blockRe#0", + "kind": "VariableDeclaration", + "name": "blockRe", + "parameters": [], + "qualified_name": "parseText.blockRe", + "returns": null, + "start_line": 107 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 110, + "start_line": 107 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.blockRe%230", + "identity": "parseText.blockRe#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.body%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.body", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 117, + "exported": false, + "identity": "parseText.body#0", + "kind": "VariableDeclaration", + "name": "body", + "parameters": [], + "qualified_name": "parseText.body", + "returns": null, + "start_line": 117 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 117, + "start_line": 117 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.body%230", + "identity": "parseText.body#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.current%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.current", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 118, + "exported": false, + "identity": "parseText.current#0", + "kind": "VariableDeclaration", + "name": "current", + "parameters": [], + "qualified_name": "parseText.current", + "returns": "Entry | null", + "start_line": 118 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 118, + "start_line": 118 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.current%230", + "identity": "parseText.current#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.entries%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.entries", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 114, + "exported": false, + "identity": "parseText.entries#0", + "kind": "VariableDeclaration", + "name": "entries", + "parameters": [], + "qualified_name": "parseText.entries", + "returns": "Entry[]", + "start_line": 114 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 114, + "start_line": 114 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.entries%230", + "identity": "parseText.entries#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.fieldRe%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.fieldRe", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 112, + "exported": false, + "identity": "parseText.fieldRe#0", + "kind": "VariableDeclaration", + "name": "fieldRe", + "parameters": [], + "qualified_name": "parseText.fieldRe", + "returns": null, + "start_line": 112 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 112, + "start_line": 112 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.fieldRe%230", + "identity": "parseText.fieldRe#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.idRe%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.idRe", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 111, + "exported": false, + "identity": "parseText.idRe#0", + "kind": "VariableDeclaration", + "name": "idRe", + "parameters": [], + "qualified_name": "parseText.idRe", + "returns": null, + "start_line": 111 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 111, + "start_line": 111 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.idRe%230", + "identity": "parseText.idRe#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.line%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.line", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 120, + "exported": false, + "identity": "parseText.line#0", + "kind": "VariableDeclaration", + "name": "line", + "parameters": [], + "qualified_name": "parseText.line", + "returns": null, + "start_line": 120 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 120, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.line%230", + "identity": "parseText.line#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.m%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.m", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 105, + "exported": false, + "identity": "parseText.m#0", + "kind": "VariableDeclaration", + "name": "m", + "parameters": [], + "qualified_name": "parseText.m", + "returns": null, + "start_line": 105 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 105, + "start_line": 105 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.m%230", + "identity": "parseText.m#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.match%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.match", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 115, + "exported": false, + "identity": "parseText.match#0", + "kind": "VariableDeclaration", + "name": "match", + "parameters": [], + "qualified_name": "parseText.match", + "returns": "RegExpExecArray | null", + "start_line": 115 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 115, + "start_line": 115 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.match%230", + "identity": "parseText.match#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.mf%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.mf", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 128, + "exported": false, + "identity": "parseText.mf#0", + "kind": "VariableDeclaration", + "name": "mf", + "parameters": [], + "qualified_name": "parseText.mf", + "returns": null, + "start_line": 128 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 128, + "start_line": 128 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.mf%230", + "identity": "parseText.mf#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.mid%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.mid", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 121, + "exported": false, + "identity": "parseText.mid#0", + "kind": "VariableDeclaration", + "name": "mid", + "parameters": [], + "qualified_name": "parseText.mid", + "returns": null, + "start_line": 121 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 121, + "start_line": 121 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.mid%230", + "identity": "parseText.mid#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.name%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.name", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 106, + "exported": false, + "identity": "parseText.name#0", + "kind": "VariableDeclaration", + "name": "name", + "parameters": [], + "qualified_name": "parseText.name", + "returns": null, + "start_line": 106 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 106, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.name%230", + "identity": "parseText.name#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.rawLine%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "parseText.rawLine", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 119, + "exported": false, + "identity": "parseText.rawLine#0", + "kind": "VariableDeclaration", + "name": "rawLine", + "parameters": [], + "qualified_name": "parseText.rawLine", + "returns": null, + "start_line": 119 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 119, + "start_line": 119 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/parseText.rawLine%230", + "identity": "parseText.rawLine#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosLineRe%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "ratiosLineRe", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 207, + "exported": false, + "identity": "ratiosLineRe#0", + "kind": "FunctionDeclaration", + "name": "ratiosLineRe", + "parameters": [ + { + "default": null, + "name": "marker", + "optional": false, + "rest": false, + "type": "string" + } + ], + "qualified_name": "ratiosLineRe", + "returns": "RegExp", + "start_line": 205 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 207, + "start_line": 205 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosLineRe%230", + "identity": "ratiosLineRe#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "ratiosPlacement", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 256, + "exported": true, + "identity": "ratiosPlacement#0", + "kind": "FunctionDeclaration", + "name": "ratiosPlacement", + "parameters": [ + { + "default": null, + "name": "text", + "optional": false, + "rest": false, + "type": "string" + }, + { + "default": "\"#\"", + "name": "marker", + "optional": false, + "rest": false, + "type": "string" + } + ], + "qualified_name": "ratiosPlacement", + "returns": "[boolean, boolean]", + "start_line": 235 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 256, + "start_line": 235 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement%230", + "identity": "ratiosPlacement#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.displacedShebang%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "ratiosPlacement.displacedShebang", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 248, + "exported": false, + "identity": "ratiosPlacement.displacedShebang#0", + "kind": "VariableDeclaration", + "name": "displacedShebang", + "parameters": [], + "qualified_name": "ratiosPlacement.displacedShebang", + "returns": null, + "start_line": 244 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 248, + "start_line": 244 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.displacedShebang%230", + "identity": "ratiosPlacement.displacedShebang#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.hasShebang%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "ratiosPlacement.hasShebang", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 239, + "exported": false, + "identity": "ratiosPlacement.hasShebang#0", + "kind": "VariableDeclaration", + "name": "hasShebang", + "parameters": [], + "qualified_name": "ratiosPlacement.hasShebang", + "returns": null, + "start_line": 239 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 239, + "start_line": 239 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.hasShebang%230", + "identity": "ratiosPlacement.hasShebang#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.i%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "ratiosPlacement.i", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 250, + "exported": false, + "identity": "ratiosPlacement.i#0", + "kind": "VariableDeclaration", + "name": "i", + "parameters": [], + "qualified_name": "ratiosPlacement.i", + "returns": null, + "start_line": 250 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 250, + "start_line": 250 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.i%230", + "identity": "ratiosPlacement.i#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.lastOk%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "ratiosPlacement.lastOk", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 249, + "exported": false, + "identity": "ratiosPlacement.lastOk#0", + "kind": "VariableDeclaration", + "name": "lastOk", + "parameters": [], + "qualified_name": "ratiosPlacement.lastOk", + "returns": null, + "start_line": 249 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 249, + "start_line": 249 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.lastOk%230", + "identity": "ratiosPlacement.lastOk#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.lineRe%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "ratiosPlacement.lineRe", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 236, + "exported": false, + "identity": "ratiosPlacement.lineRe#0", + "kind": "VariableDeclaration", + "name": "lineRe", + "parameters": [], + "qualified_name": "ratiosPlacement.lineRe", + "returns": null, + "start_line": 236 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 236, + "start_line": 236 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.lineRe%230", + "identity": "ratiosPlacement.lineRe#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.lines%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "ratiosPlacement.lines", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 237, + "exported": false, + "identity": "ratiosPlacement.lines#0", + "kind": "VariableDeclaration", + "name": "lines", + "parameters": [], + "qualified_name": "ratiosPlacement.lines", + "returns": null, + "start_line": 237 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 237, + "start_line": 237 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.lines%230", + "identity": "ratiosPlacement.lines#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.openingIndex%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "ratiosPlacement.openingIndex", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 240, + "exported": false, + "identity": "ratiosPlacement.openingIndex#0", + "kind": "VariableDeclaration", + "name": "openingIndex", + "parameters": [], + "qualified_name": "ratiosPlacement.openingIndex", + "returns": null, + "start_line": 240 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 240, + "start_line": 240 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.openingIndex%230", + "identity": "ratiosPlacement.openingIndex#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.openingOk%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "ratiosPlacement.openingOk", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 243, + "exported": false, + "identity": "ratiosPlacement.openingOk#0", + "kind": "VariableDeclaration", + "name": "openingOk", + "parameters": [], + "qualified_name": "ratiosPlacement.openingOk", + "returns": null, + "start_line": 241 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 243, + "start_line": 241 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/ratiosPlacement.openingOk%230", + "identity": "ratiosPlacement.openingOk#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "exported-declaration", + "native": { + "id": "walkTree", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 195, + "exported": true, + "identity": "walkTree#0", + "kind": "FunctionDeclaration", + "name": "walkTree", + "parameters": [ + { + "default": null, + "name": "root", + "optional": false, + "rest": false, + "type": "string" + }, + { + "default": null, + "name": "blockName", + "optional": false, + "rest": false, + "type": "string" + }, + { + "default": "{}", + "name": "opts", + "optional": false, + "rest": false, + "type": "WalkOptions" + } + ], + "qualified_name": "walkTree", + "returns": "{ annotated: Array<[string, Entry[]]>; untested: string[] }", + "start_line": 151 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 195, + "start_line": 151 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree%230", + "identity": "walkTree#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.annotated%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.annotated", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 155, + "exported": false, + "identity": "walkTree.annotated#0", + "kind": "PropertySignature", + "name": "annotated", + "parameters": [], + "qualified_name": "walkTree.annotated", + "returns": "Array<[string, Entry[]]>", + "start_line": 155 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 155, + "start_line": 155 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.annotated%230", + "identity": "walkTree.annotated#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.annotated%231/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.annotated", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 160, + "exported": false, + "identity": "walkTree.annotated#1", + "kind": "VariableDeclaration", + "name": "annotated", + "parameters": [], + "qualified_name": "walkTree.annotated", + "returns": "Array<[string, Entry[]]>", + "start_line": 160 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 160, + "start_line": 160 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.annotated%231", + "identity": "walkTree.annotated#1", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.extensions%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.extensions", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 158, + "exported": false, + "identity": "walkTree.extensions#0", + "kind": "VariableDeclaration", + "name": "extensions", + "parameters": [], + "qualified_name": "walkTree.extensions", + "returns": null, + "start_line": 157 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 158, + "start_line": 157 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.extensions%230", + "identity": "walkTree.extensions#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.skip%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.skip", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 156, + "exported": false, + "identity": "walkTree.skip#0", + "kind": "VariableDeclaration", + "name": "skip", + "parameters": [], + "qualified_name": "walkTree.skip", + "returns": null, + "start_line": 156 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 156, + "start_line": 156 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.skip%230", + "identity": "walkTree.skip#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.untested%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.untested", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 155, + "exported": false, + "identity": "walkTree.untested#0", + "kind": "PropertySignature", + "name": "untested", + "parameters": [], + "qualified_name": "walkTree.untested", + "returns": "string[]", + "start_line": 155 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 155, + "start_line": 155 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.untested%230", + "identity": "walkTree.untested#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.untested%231/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.untested", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 161, + "exported": false, + "identity": "walkTree.untested#1", + "kind": "VariableDeclaration", + "name": "untested", + "parameters": [], + "qualified_name": "walkTree.untested", + "returns": "string[]", + "start_line": 161 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 161, + "start_line": 161 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.untested%231", + "identity": "walkTree.untested#1", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.visit", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 191, + "exported": false, + "identity": "walkTree.visit#0", + "kind": "FunctionDeclaration", + "name": "visit", + "parameters": [ + { + "default": null, + "name": "dir", + "optional": false, + "rest": false, + "type": "string" + } + ], + "qualified_name": "walkTree.visit", + "returns": "void", + "start_line": 163 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 191, + "start_line": 163 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit%230", + "identity": "walkTree.visit#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit.entries%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.visit.entries", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 183, + "exported": false, + "identity": "walkTree.visit.entries#0", + "kind": "VariableDeclaration", + "name": "entries", + "parameters": [], + "qualified_name": "walkTree.visit.entries", + "returns": null, + "start_line": 183 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 183, + "start_line": 183 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit.entries%230", + "identity": "walkTree.visit.entries#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit.full%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.visit.full", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 172, + "exported": false, + "identity": "walkTree.visit.full#0", + "kind": "VariableDeclaration", + "name": "full", + "parameters": [], + "qualified_name": "walkTree.visit.full", + "returns": null, + "start_line": 172 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 172, + "start_line": 172 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit.full%230", + "identity": "walkTree.visit.full#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit.name%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.visit.name", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 170, + "exported": false, + "identity": "walkTree.visit.name#0", + "kind": "VariableDeclaration", + "name": "name", + "parameters": [], + "qualified_name": "walkTree.visit.name", + "returns": null, + "start_line": 170 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 170, + "start_line": 170 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit.name%230", + "identity": "walkTree.visit.name#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit.names%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.visit.names", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 164, + "exported": false, + "identity": "walkTree.visit.names#0", + "kind": "VariableDeclaration", + "name": "names", + "parameters": [], + "qualified_name": "walkTree.visit.names", + "returns": "string[]", + "start_line": 164 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 164, + "start_line": 164 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit.names%230", + "identity": "walkTree.visit.names#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit.st%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "walkTree.visit.st", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 173, + "exported": false, + "identity": "walkTree.visit.st#0", + "kind": "VariableDeclaration", + "name": "st", + "parameters": [], + "qualified_name": "walkTree.visit.st", + "returns": null, + "start_line": 173 + } + }, + "origin": "native", + "source": { + "content_sha256": "b6b8350b1180770822bebab277b39ef0707d0ca71b96b47750021589c37fa4a9", + "file": "msdmd/parsers/universal.ts", + "location": { + "end_line": 173, + "start_line": 173 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/parsers/universal.ts#subject/symbol/walkTree.visit.st%230", + "identity": "walkTree.visit.st#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/python-module-reader.json#subject/document/msdmd%2Fpython-module-reader.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "json.document", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "attachment": { + "leading_trivia": "Attach a contiguous comment group to the immediately following declaration when lexical columns match.", + "module_convention": "Keep shebangs, encoding cookies, RATIOS seals, and MSDMD fences at module scope.", + "module_scope": "Keep otherwise unattached comments at module scope.", + "native_docstring": "Attach to the AST owner.", + "nearest_enclosing_symbol": "Attach every other interior comment to the deepest enclosing declaration, whose region begins at its first decorator and extends through trailing indented comments until lexical dedent." + }, + "conventions": [ + "python.ast.declaration", + "python.docstring.pep257", + "python.line-comment", + "python.encoding-cookie", + "msdmd.fenced-block", + "msdmd.ratios" + ], + "dependencies": [ + "python-stdlib:ast", + "python-stdlib:tokenize" + ], + "detection": { + "ambiguity": "Files without a .py suffix and Python-compatible embedded languages are not guessed.", + "language_context": "Explicit Python source selection or .py tree discovery.", + "suffixes": [ + ".py" + ] + }, + "entry_point": "msdmd/module_projection.py", + "failure_behavior": "Invalid syntax, incomplete tokenization, or a malformed MSDMD fence (interrupted, unclosed, name-mismatched, nested opening, or unmatched close) emits a diagnostic and causes --check or --write to exit nonzero. Fence validation is stricter than the universal block parser.", + "field_mapping": { + "ast_declaration": "symbol", + "ast_decorator": "symbol.decorators", + "ast_signature": "symbol.signature", + "docstring": "metadata:documentation", + "line_comment": "metadata:comment" + }, + "fixtures": "tests/test_module_projection.py", + "limitations": [ + "imports and dependency edges", + "call graphs and runtime behavior", + "dynamic exports and evaluated annotations", + "Sphinx, Google, and NumPy docstring field parsing", + ".pyi-specific semantics", + "cross-revision rename identity", + "repository discovery and exclusion receipts", + "reconciliation with non-Python or MSDMD block collections", + "raw-file byte offsets: span byte offsets index the UTF-8 re-encoding of the decoded source text and differ from raw file offsets for BOM-prefixed or non-UTF-8 sources" + ], + "output_schema": "msdmd/module-projection.schema.json", + "reader_id": "the-interdependency.msdmd.python-ast-tokenize", + "reader_version": "1.0.0", + "safety": { + "executes_inspected_code": false, + "follows_external_references": false, + "imports_inspected_modules": false, + "network_access": false + }, + "status": "partial", + "supported_grammar": { + "freshness_binding": "All three runtime fields participate in freshness_key_sha256.", + "projection_fields": [ + "python_implementation", + "python_version", + "ast_feature_version" + ], + "selection": "The grammar of the executing Python runtime, passed explicitly to ast.parse as feature_version." + }, + "supported_subset": [ + "module, class, function, async-function, method, and async-method AST ownership", + "qualified symbol identities and signatures", + "decorator spelling recovered with ast.unparse and source_span extended across decorator syntax", + "module, class, function, and method docstrings", + "syntax-aware Python line comments", + "leading-trivia and nearest-enclosing-symbol comment attachment, including decorator-region comments and trailing suite comments before lexical dedent", + "shebang, encoding-cookie, RATIOS, and MSDMD-fence module conventions", + "UTF-8 projection spans over decoded source split only at Python newlines (LF, CRLF, CR), including CR-only sources, and raw-source SHA-256", + "projection files written as exact UTF-8 bytes with LF record terminators on every platform", + "parse, tokenization, and malformed MSDMD-fence diagnostics: interrupted, unclosed, name-mismatched or nested-opening (msdmd_fence_mismatched), and unmatched-close (msdmd_fence_unmatched_close) fences, where a mismatch yields one diagnostic because one later close per affected block name, orphaned by that reported mismatch, is suppressed until the next opening of that name (an interrupted fence may also report its later close as msdmd_fence_unmatched_close); stricter than the universal block parser, which matches each block name independently" + ], + "unknown_field_policy": "Unsupported semantic parsing is not fabricated; the partial scope remains declared in this manifest and repository guidance." + } + }, + "origin": "native", + "source": { + "content_sha256": "c9cdc7dfe93cd7378820b37b25b672541c50faf8c42c41f36661fa55248dbadf", + "file": "msdmd/python-module-reader.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/python-module-reader.json#subject/document/msdmd%2Fpython-module-reader.json", + "identity": "msdmd/python-module-reader.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "267:28" + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A1009-1009/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "267:28" + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 1009, + "start_line": 1009 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "22:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A1009-1009/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "22:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 1009, + "start_line": 1009 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "889:48" + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A1009-1009/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "889:48" + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 1009, + "start_line": 1009 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=889:48 imports_exports=22:5 calls_definitions=267:28" + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 75, + "column": 75, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: msdmd_native_reader_registry\n module_name: readers\n module_kind: instrument\n summary: statically extracts supported native metadata conventions into provenance-bearing MSDMD facts\n owner: The Interdependency skill-lib\n public_surface: READER_MANIFESTS, readers_for, reader_for, read_native\n internal_surface: convention-specific pure readers and source-qualified fact helpers\n auth_boundary: none\n storage_boundary: read\n network_boundary: none\n user_data_boundary: read\n admin_only: false\n tests: tests/test_native_collection.py\n rollout: enable through msdmd.collect schema 2 collections\n rollback: retain schema 1 block-only consumers while removing the schema 2 runner claim\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 18, + "span": { + "end": { + "byte": 852, + "column": 26, + "line": 18 + }, + "start": { + "byte": 76, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=889:48 imports_exports=22:5 calls_definitions=267:28" + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 1009, + "span": { + "end": { + "byte": 56485, + "column": 75, + "line": 1009 + }, + "start": { + "byte": 56410, + "column": 0, + "line": 1009 + } + }, + "start_line": 1009 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::<module>", + "description": "Usage guidance:\n Call ``read_native(path, bytes, context)`` only with bytes already bounded\n by the collector. Readers never import inspected Python, execute scripts,\n expand templates, or resolve network references. ``READER_MANIFESTS`` is\n emitted in every collection so consumers can negotiate the exact supported\n subset instead of treating file recognition as full language support.\n\nThe registry intentionally implements conventions exercised by skill-lib and\nthe MSDMD worked example: Python syntax/docstrings/imports, RATIOS boundary\nlines, JSON documents, TOML manifests, Markdown YAML frontmatter, safe YAML and\nJavaScript/TypeScript subsets, GitHub CODEOWNERS, shell declarations, systemd\nunits, Git ignore rules, Python requirements files, bounded license detection,\nSVG document metadata, and root ``llms.txt`` structure. Unmatched inputs stay\nvisible in the collection discovery ledger as unsupported ``hmmm`` scope.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Static native metadata readers used by :mod:`msdmd.collect`.", + "text": "Static native metadata readers used by :mod:`msdmd.collect`.\n\nUsage guidance:\n Call ``read_native(path, bytes, context)`` only with bytes already bounded\n by the collector. Readers never import inspected Python, execute scripts,\n expand templates, or resolve network references. ``READER_MANIFESTS`` is\n emitted in every collection so consumers can negotiate the exact supported\n subset instead of treating file recognition as full language support.\n\nThe registry intentionally implements conventions exercised by skill-lib and\nthe MSDMD worked example: Python syntax/docstrings/imports, RATIOS boundary\nlines, JSON documents, TOML manifests, Markdown YAML frontmatter, safe YAML and\nJavaScript/TypeScript subsets, GitHub CODEOWNERS, shell declarations, systemd\nunits, Git ignore rules, Python requirements files, bounded license detection,\nSVG document metadata, and root ``llms.txt`` structure. Unmatched inputs stay\nvisible in the collection discovery ledger as unsupported ``hmmm`` scope.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 35, + "span": { + "end": { + "byte": 1867, + "column": 3, + "line": 35 + }, + "start": { + "byte": 853, + "column": 0, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 36, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "functools:lru_cache:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "functools", + "name": "lru_cache" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 38, + "start_line": 38 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tokenize:tokenize:10", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tokenize", + "name": "tokenize" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 47, + "start_line": 47 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tomllib:tomllib:11", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tomllib", + "name": "tomllib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 48, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/12", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "xml.etree.ElementTree:xml.etree.ElementTree:12", + "value": { + "alias": "ET", + "kind": "import", + "level": 0, + "module": "xml.etree.ElementTree", + "name": "xml.etree.ElementTree" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 49, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/13", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "collections:Counter:13", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "collections", + "name": "Counter" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 50, + "start_line": 50 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/14", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:14", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 51, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/15", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:15", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 52, + "start_line": 52 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/16", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Callable:16", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Callable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 52, + "start_line": 52 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/17", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "urllib.parse:quote:17", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "urllib.parse", + "name": "quote" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 53, + "start_line": 53 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/18", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:marker_for:18", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "marker_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 55, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/19", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:parse_ratios:19", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "parse_ratios" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 55, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "datetime:datetime:2", + "value": { + "alias": "dt", + "kind": "import", + "level": 0, + "module": "datetime", + "name": "datetime" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 39, + "start_line": 39 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/20", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:ratios_placement:20", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "ratios_placement" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 55, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/21", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:is_json_schema_uri:21", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "is_json_schema_uri" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 56, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/22", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:parse_json:22", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "parse_json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 56, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/23", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:parse_yaml:23", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "parse_yaml" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 56, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/24", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:parse_xml:24", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "parse_xml" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 56, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/25", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.grammar_code:read_grammar:25", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.grammar_code", + "name": "read_grammar" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 57, + "start_line": 57 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/26", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.native_code:read_python:26", + "value": { + "alias": "_read_python", + "kind": "from_import", + "level": 0, + "module": "msdmd.native_code", + "name": "read_python" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 58, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/27", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.native_code:read_typescript:27", + "value": { + "alias": "_read_typescript", + "kind": "from_import", + "level": 0, + "module": "msdmd.native_code", + "name": "read_typescript" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 58, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/28", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.standards:read_standards:28", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.standards", + "name": "read_standards" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 59, + "start_line": 59 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 40, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "io:io:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "io", + "name": "io" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 41, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 42, + "start_line": 42 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "math:math:6", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "math", + "name": "math" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 43, + "start_line": 43 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:7", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 44, + "start_line": 44 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "shlex:shlex:8", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "shlex", + "name": "shlex" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 45, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:9", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 46, + "start_line": 46 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/module/msdmd%2Freaders.py", + "identity": "msdmd/readers.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_diagnostic/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_diagnostic", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_diagnostic", + "decorators": [], + "kind": "function", + "name": "_diagnostic", + "parent_identity": null, + "qualified_name": "_diagnostic", + "signature": "def _diagnostic(context: dict[str, Any], *, reader_id: str, code: str, message: str, status: str, severity: str='warning', location: dict[str, Any] | None=None) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 471, + "span": { + "end": { + "byte": 22520, + "column": 5, + "line": 471 + }, + "start": { + "byte": 22072, + "column": 0, + "line": 454 + } + }, + "start_line": 454 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_diagnostic", + "identity": "_diagnostic", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_digest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_digest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_digest", + "decorators": [], + "kind": "function", + "name": "_digest", + "parent_identity": null, + "qualified_name": "_digest", + "signature": "def _digest(value: bytes | str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 327, + "span": { + "end": { + "byte": 17344, + "column": 43, + "line": 327 + }, + "start": { + "byte": 17189, + "column": 0, + "line": 325 + } + }, + "start_line": 325 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_digest", + "identity": "_digest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_edge/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_edge", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_edge", + "decorators": [], + "kind": "function", + "name": "_edge", + "parent_identity": null, + "qualified_name": "_edge", + "signature": "def _edge(source: str, target: str, kind: str, *, standing: str='syntactically-observed') -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 481, + "span": { + "end": { + "byte": 22805, + "column": 5, + "line": 481 + }, + "start": { + "byte": 22523, + "column": 0, + "line": 474 + } + }, + "start_line": 474 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_edge", + "identity": "_edge", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_fact/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_fact", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_fact", + "decorators": [], + "kind": "function", + "name": "_fact", + "parent_identity": null, + "qualified_name": "_fact", + "signature": "def _fact(context: dict[str, Any], *, reader_id: str, kind: str, scope: str, identity: str, location: dict[str, Any], value: Any, native_id: str | None=None, convention: str | None=None, standing: str='syntactically-observed', projection: dict[str, Any] | None=None) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 451, + "span": { + "end": { + "byte": 22069, + "column": 17, + "line": 451 + }, + "start": { + "byte": 20431, + "column": 0, + "line": 407 + } + }, + "start_line": 407 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_fact", + "identity": "_fact", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_json_safe/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_json_safe", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_json_safe", + "decorators": [], + "kind": "function", + "name": "_json_safe", + "parent_identity": null, + "qualified_name": "_json_safe", + "signature": "def _json_safe(value: Any) -> Any" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 342, + "span": { + "end": { + "byte": 18100, + "column": 81, + "line": 342 + }, + "start": { + "byte": 17347, + "column": 0, + "line": 330 + } + }, + "start_line": 330 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_json_safe", + "identity": "_json_safe", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_json_safe/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_json_safe", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Preserve non-JSON native scalar types with explicit tagged values.", + "text": "Preserve non-JSON native scalar types with explicit tagged values." + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 331, + "span": { + "end": { + "byte": 17458, + "column": 76, + "line": 331 + }, + "start": { + "byte": 17386, + "column": 4, + "line": 331 + } + }, + "start_line": 331 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_json_safe", + "identity": "_json_safe", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_quoted/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_quoted", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_quoted", + "decorators": [], + "kind": "function", + "name": "_quoted", + "parent_identity": null, + "qualified_name": "_quoted", + "signature": "def _quoted(value: str, *, path: bool=False) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 387, + "span": { + "end": { + "byte": 19855, + "column": 49, + "line": 387 + }, + "start": { + "byte": 19751, + "column": 0, + "line": 386 + } + }, + "start_line": 386 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_quoted", + "identity": "_quoted", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_codeowners/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_codeowners", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_codeowners", + "decorators": [], + "kind": "function", + "name": "_read_codeowners", + "parent_identity": null, + "qualified_name": "_read_codeowners", + "signature": "def _read_codeowners(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 647, + "span": { + "end": { + "byte": 34239, + "column": 33, + "line": 647 + }, + "start": { + "byte": 32175, + "column": 0, + "line": 623 + } + }, + "start_line": 623 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_codeowners", + "identity": "_read_codeowners", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_gitignore/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_gitignore", + "metadata_kind": "comment", + "text": "Git ignores unescaped trailing spaces. Count backslash parity so\nan escaped space survives, including before later unescaped spaces." + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 773, + "span": { + "end": { + "byte": 41181, + "column": 77, + "line": 773 + }, + "start": { + "byte": 41037, + "column": 8, + "line": 772 + } + }, + "start_line": 772 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_gitignore", + "identity": "_read_gitignore", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_gitignore/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_gitignore", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_gitignore", + "decorators": [], + "kind": "function", + "name": "_read_gitignore", + "parent_identity": null, + "qualified_name": "_read_gitignore", + "signature": "def _read_gitignore(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 785, + "span": { + "end": { + "byte": 41967, + "column": 24, + "line": 785 + }, + "start": { + "byte": 40432, + "column": 0, + "line": 762 + } + }, + "start_line": 762 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_gitignore", + "identity": "_read_gitignore", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_json/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_json", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_json", + "decorators": [], + "kind": "function", + "name": "_read_json", + "parent_identity": null, + "qualified_name": "_read_json", + "signature": "def _read_json(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 555, + "span": { + "end": { + "byte": 27737, + "column": 59, + "line": 555 + }, + "start": { + "byte": 25057, + "column": 0, + "line": 520 + } + }, + "start_line": 520 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_json", + "identity": "_read_json", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_license/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_license", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_license", + "decorators": [], + "kind": "function", + "name": "_read_license", + "parent_identity": null, + "qualified_name": "_read_license", + "signature": "def _read_license(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 845, + "span": { + "end": { + "byte": 46504, + "column": 34, + "line": 845 + }, + "start": { + "byte": 44956, + "column": 0, + "line": 826 + } + }, + "start_line": 826 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_license", + "identity": "_read_license", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_llms_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_llms_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_llms_text", + "decorators": [], + "kind": "function", + "name": "_read_llms_text", + "parent_identity": null, + "qualified_name": "_read_llms_text", + "signature": "def _read_llms_text(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 894, + "span": { + "end": { + "byte": 49629, + "column": 24, + "line": 894 + }, + "start": { + "byte": 48082, + "column": 0, + "line": 876 + } + }, + "start_line": 876 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_llms_text", + "identity": "_read_llms_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_markdown/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_markdown", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_markdown", + "decorators": [], + "kind": "function", + "name": "_read_markdown", + "parent_identity": null, + "qualified_name": "_read_markdown", + "signature": "def _read_markdown(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 610, + "span": { + "end": { + "byte": 31573, + "column": 56, + "line": 610 + }, + "start": { + "byte": 30435, + "column": 0, + "line": 593 + } + }, + "start_line": 593 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_markdown", + "identity": "_read_markdown", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_ratios/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_ratios", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_ratios", + "decorators": [], + "kind": "function", + "name": "_read_ratios", + "parent_identity": null, + "qualified_name": "_read_ratios", + "signature": "def _read_ratios(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 517, + "span": { + "end": { + "byte": 25054, + "column": 33, + "line": 517 + }, + "start": { + "byte": 22808, + "column": 0, + "line": 484 + } + }, + "start_line": 484 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_ratios", + "identity": "_read_ratios", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_requirements/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_requirements", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_requirements", + "decorators": [], + "kind": "function", + "name": "_read_requirements", + "parent_identity": null, + "qualified_name": "_read_requirements", + "signature": "def _read_requirements(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 823, + "span": { + "end": { + "byte": 44953, + "column": 36, + "line": 823 + }, + "start": { + "byte": 42048, + "column": 0, + "line": 791 + } + }, + "start_line": 791 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_requirements", + "identity": "_read_requirements", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_shell/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_shell", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_shell", + "decorators": [], + "kind": "function", + "name": "_read_shell", + "parent_identity": null, + "qualified_name": "_read_shell", + "signature": "def _read_shell(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 665, + "span": { + "end": { + "byte": 35579, + "column": 24, + "line": 665 + }, + "start": { + "byte": 34242, + "column": 0, + "line": 650 + } + }, + "start_line": 650 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_shell", + "identity": "_read_shell", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_svg/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_svg", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_svg", + "decorators": [], + "kind": "function", + "name": "_read_svg", + "parent_identity": null, + "qualified_name": "_read_svg", + "signature": "def _read_svg(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 869, + "span": { + "end": { + "byte": 47909, + "column": 95, + "line": 869 + }, + "start": { + "byte": 46507, + "column": 0, + "line": 848 + } + }, + "start_line": 848 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_svg", + "identity": "_read_svg", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_systemd/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_systemd", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_systemd", + "decorators": [], + "kind": "function", + "name": "_read_systemd", + "parent_identity": null, + "qualified_name": "_read_systemd", + "signature": "def _read_systemd(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 759, + "span": { + "end": { + "byte": 40429, + "column": 33, + "line": 759 + }, + "start": { + "byte": 37346, + "column": 0, + "line": 711 + } + }, + "start_line": 711 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_systemd", + "identity": "_read_systemd", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_toml/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_toml", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_toml", + "decorators": [], + "kind": "function", + "name": "_read_toml", + "parent_identity": null, + "qualified_name": "_read_toml", + "signature": "def _read_toml(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 590, + "span": { + "end": { + "byte": 30432, + "column": 59, + "line": 590 + }, + "start": { + "byte": 27740, + "column": 0, + "line": 558 + } + }, + "start_line": 558 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_toml", + "identity": "_read_toml", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_yaml/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_yaml", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_read_yaml", + "decorators": [], + "kind": "function", + "name": "_read_yaml", + "parent_identity": null, + "qualified_name": "_read_yaml", + "signature": "def _read_yaml(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 620, + "span": { + "end": { + "byte": 32172, + "column": 57, + "line": 620 + }, + "start": { + "byte": 31576, + "column": 0, + "line": 613 + } + }, + "start_line": 613 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_read_yaml", + "identity": "_read_yaml", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_redact_sensitive/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_redact_sensitive", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_redact_sensitive", + "decorators": [], + "kind": "function", + "name": "_redact_sensitive", + "parent_identity": null, + "qualified_name": "_redact_sensitive", + "signature": "def _redact_sensitive(value: Any, pointer: str='') -> tuple[Any, list[str]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 370, + "span": { + "end": { + "byte": 19348, + "column": 26, + "line": 370 + }, + "start": { + "byte": 18103, + "column": 0, + "line": 345 + } + }, + "start_line": 345 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_redact_sensitive", + "identity": "_redact_sensitive", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_redact_sensitive/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_redact_sensitive", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Redact values owned by plainly secret-bearing field names.", + "text": "Redact values owned by plainly secret-bearing field names." + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 346, + "span": { + "end": { + "byte": 18250, + "column": 68, + "line": 346 + }, + "start": { + "byte": 18186, + "column": 4, + "line": 346 + } + }, + "start_line": 346 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_redact_sensitive", + "identity": "_redact_sensitive", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_redact_systemd_environment/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_redact_systemd_environment", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_redact_systemd_environment", + "decorators": [], + "kind": "function", + "name": "_redact_systemd_environment", + "parent_identity": null, + "qualified_name": "_redact_systemd_environment", + "signature": "def _redact_systemd_environment(value: str) -> tuple[str, bool, bool]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 708, + "span": { + "end": { + "byte": 37343, + "column": 42, + "line": 708 + }, + "start": { + "byte": 35582, + "column": 0, + "line": 668 + } + }, + "start_line": 668 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_redact_systemd_environment", + "identity": "_redact_systemd_environment", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_redact_systemd_environment/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_redact_systemd_environment", + "description": "Unknown quoting/escaping withholds the entire value rather than\napplying shell rules to systemd syntax or publishing possible secrets.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Redact every assignment in the supported, non-escaped word subset.", + "text": "Redact every assignment in the supported, non-escaped word subset.\n\n Unknown quoting/escaping withholds the entire value rather than\n applying shell rules to systemd syntax or publishing possible secrets.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 673, + "span": { + "end": { + "byte": 35878, + "column": 7, + "line": 673 + }, + "start": { + "byte": 35657, + "column": 4, + "line": 669 + } + }, + "start_line": 669 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_redact_systemd_environment", + "identity": "_redact_systemd_environment", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_redaction_diagnostic/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_redaction_diagnostic", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_redaction_diagnostic", + "decorators": [], + "kind": "function", + "name": "_redaction_diagnostic", + "parent_identity": null, + "qualified_name": "_redaction_diagnostic", + "signature": "def _redaction_diagnostic(context: dict[str, Any], reader_id: str, pointers: list[str]) -> dict[str, Any] | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 383, + "span": { + "end": { + "byte": 19748, + "column": 5, + "line": 383 + }, + "start": { + "byte": 19351, + "column": 0, + "line": 373 + } + }, + "start_line": 373 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_redaction_diagnostic", + "identity": "_redaction_diagnostic", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_source/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_source", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_source", + "decorators": [], + "kind": "function", + "name": "_source", + "parent_identity": null, + "qualified_name": "_source", + "signature": "def _source(context: dict[str, Any], location: dict[str, Any]) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 397, + "span": { + "end": { + "byte": 20154, + "column": 5, + "line": 397 + }, + "start": { + "byte": 19858, + "column": 0, + "line": 390 + } + }, + "start_line": 390 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_source", + "identity": "_source", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_subject_address/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_subject_address", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:_subject_address", + "decorators": [], + "kind": "function", + "name": "_subject_address", + "parent_identity": null, + "qualified_name": "_subject_address", + "signature": "def _subject_address(context: dict[str, Any], scope: str, identity: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 404, + "span": { + "end": { + "byte": 20428, + "column": 5, + "line": 404 + }, + "start": { + "byte": 20157, + "column": 0, + "line": 400 + } + }, + "start_line": 400 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/_subject_address", + "identity": "_subject_address", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/implementation_digest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "implementation_digest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:implementation_digest", + "decorators": [ + "lru_cache(maxsize=1)" + ], + "kind": "function", + "name": "implementation_digest", + "parent_identity": null, + "qualified_name": "implementation_digest", + "signature": "def implementation_digest() -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 905, + "span": { + "end": { + "byte": 50246, + "column": 29, + "line": 905 + }, + "start": { + "byte": 49632, + "column": 0, + "line": 897 + } + }, + "start_line": 897 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/implementation_digest", + "identity": "implementation_digest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/implementation_digest/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:implementation_digest", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Identity of all executable reader inputs, independent of inspected files.", + "text": "Identity of all executable reader inputs, independent of inspected files." + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 899, + "span": { + "end": { + "byte": 49773, + "column": 83, + "line": 899 + }, + "start": { + "byte": 49694, + "column": 4, + "line": 899 + } + }, + "start_line": 899 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/implementation_digest", + "identity": "implementation_digest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/read_native/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:read_native", + "metadata_kind": "comment", + "text": "Malformed inputs do not stop independent files. Do not publish exception\ntext: parser messages can contain source literals or credentials." + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 991, + "span": { + "end": { + "byte": 55304, + "column": 79, + "line": 991 + }, + "start": { + "byte": 55150, + "column": 12, + "line": 990 + } + }, + "start_line": 990 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/read_native", + "identity": "read_native", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/read_native/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:read_native", + "metadata_kind": "comment", + "text": "The same complete owning tree is emitted once even when a standard adapter\nadds a more precise root classification than the generic syntax reader." + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 1003, + "span": { + "end": { + "byte": 55989, + "column": 77, + "line": 1003 + }, + "start": { + "byte": 55835, + "column": 4, + "line": 1002 + } + }, + "start_line": 1002 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/read_native", + "identity": "read_native", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/read_native/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_native", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:read_native", + "decorators": [], + "kind": "function", + "name": "read_native", + "parent_identity": null, + "qualified_name": "read_native", + "signature": "def read_native(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list[str], list[dict], list[dict], list[dict]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 1008, + "span": { + "end": { + "byte": 56409, + "column": 48, + "line": 1008 + }, + "start": { + "byte": 53158, + "column": 0, + "line": 961 + } + }, + "start_line": 961 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/read_native", + "identity": "read_native", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/read_native/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:read_native", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Read one immutable source buffer with every applicable native reader.", + "text": "Read one immutable source buffer with every applicable native reader." + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 962, + "span": { + "end": { + "byte": 53360, + "column": 79, + "line": 962 + }, + "start": { + "byte": 53285, + "column": 4, + "line": 962 + } + }, + "start_line": 962 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/read_native", + "identity": "read_native", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/reader_for/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "reader_for", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:reader_for", + "decorators": [], + "kind": "function", + "name": "reader_for", + "parent_identity": null, + "qualified_name": "reader_for", + "signature": "def reader_for(path: Path, data: bytes | None=None) -> tuple[str, Reader] | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 958, + "span": { + "end": { + "byte": 53155, + "column": 44, + "line": 958 + }, + "start": { + "byte": 52905, + "column": 0, + "line": 955 + } + }, + "start_line": 955 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/reader_for", + "identity": "reader_for", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/reader_for/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:reader_for", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return the primary reader for compatibility; prefer :func:`readers_for`.", + "text": "Return the primary reader for compatibility; prefer :func:`readers_for`." + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 956, + "span": { + "end": { + "byte": 53071, + "column": 82, + "line": 956 + }, + "start": { + "byte": 52993, + "column": 4, + "line": 956 + } + }, + "start_line": 956 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/reader_for", + "identity": "reader_for", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/readers_for/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "readers_for", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:readers_for", + "decorators": [], + "kind": "function", + "name": "readers_for", + "parent_identity": null, + "qualified_name": "readers_for", + "signature": "def readers_for(path: Path, data: bytes | None=None) -> list[tuple[str, Reader]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 952, + "span": { + "end": { + "byte": 52902, + "column": 19, + "line": 952 + }, + "start": { + "byte": 50343, + "column": 0, + "line": 911 + } + }, + "start_line": 911 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/readers_for", + "identity": "readers_for", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/readers_for/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/readers.py::function:readers_for", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return every compatible reader selected for ``path``.", + "text": "Return every compatible reader selected for ``path``." + } + }, + "origin": "native", + "source": { + "content_sha256": "af3d0121c62c6b976064eaa3be2e648694ca7c81aac0e6959dd13c2053b0e330", + "file": "msdmd/readers.py", + "location": { + "end_line": 912, + "span": { + "end": { + "byte": 50490, + "column": 63, + "line": 912 + }, + "start": { + "byte": 50431, + "column": 4, + "line": 912 + } + }, + "start_line": 912 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/readers.py#subject/symbol/readers_for", + "identity": "readers_for", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A1/fact/dependency/lines%3A3-3/PyYAML", + "convention": { + "dialect": "requirements", + "namespace": "python.requirements-file", + "version": "PyPA requirements file subset v1" + }, + "extraction": { + "configuration_sha256": "c471ab3438cdba6c5142e03413c15f5d434f9e9bd7fa4ad5e20afbc9252949e2", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-requirements", + "reader_version": "1.0.0", + "support": "partial" + }, + "kind": "dependency", + "native": { + "id": "PyYAML", + "value": { + "class": "runtime-or-unresolved", + "name": "PyYAML", + "order": 1, + "requirement": "PyYAML==6.0.3" + } + }, + "origin": "native", + "projection": { + "loss": "resolution and environment markers not evaluated", + "mapping_version": "requirements-lines@1", + "relation": "depends_on" + }, + "source": { + "content_sha256": "b845de01c1943a4dd9494616548e3997d0a3f11df28265073bd5446fb86ae948", + "file": "msdmd/requirements.txt", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A1", + "identity": "requirement:1", + "scope": "requirements-document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A2/fact/dependency/lines%3A4-4/docstring-parser", + "convention": { + "dialect": "requirements", + "namespace": "python.requirements-file", + "version": "PyPA requirements file subset v1" + }, + "extraction": { + "configuration_sha256": "c471ab3438cdba6c5142e03413c15f5d434f9e9bd7fa4ad5e20afbc9252949e2", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-requirements", + "reader_version": "1.0.0", + "support": "partial" + }, + "kind": "dependency", + "native": { + "id": "docstring-parser", + "value": { + "class": "runtime-or-unresolved", + "name": "docstring-parser", + "order": 2, + "requirement": "docstring-parser==0.18.0" + } + }, + "origin": "native", + "projection": { + "loss": "resolution and environment markers not evaluated", + "mapping_version": "requirements-lines@1", + "relation": "depends_on" + }, + "source": { + "content_sha256": "b845de01c1943a4dd9494616548e3997d0a3f11df28265073bd5446fb86ae948", + "file": "msdmd/requirements.txt", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A2", + "identity": "requirement:2", + "scope": "requirements-document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A3/fact/dependency/lines%3A5-5/tree-sitter", + "convention": { + "dialect": "requirements", + "namespace": "python.requirements-file", + "version": "PyPA requirements file subset v1" + }, + "extraction": { + "configuration_sha256": "c471ab3438cdba6c5142e03413c15f5d434f9e9bd7fa4ad5e20afbc9252949e2", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-requirements", + "reader_version": "1.0.0", + "support": "partial" + }, + "kind": "dependency", + "native": { + "id": "tree-sitter", + "value": { + "class": "runtime-or-unresolved", + "name": "tree-sitter", + "order": 3, + "requirement": "tree-sitter==0.26.0" + } + }, + "origin": "native", + "projection": { + "loss": "resolution and environment markers not evaluated", + "mapping_version": "requirements-lines@1", + "relation": "depends_on" + }, + "source": { + "content_sha256": "b845de01c1943a4dd9494616548e3997d0a3f11df28265073bd5446fb86ae948", + "file": "msdmd/requirements.txt", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A3", + "identity": "requirement:3", + "scope": "requirements-document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A4/fact/dependency/lines%3A6-6/tree-sitter-rust", + "convention": { + "dialect": "requirements", + "namespace": "python.requirements-file", + "version": "PyPA requirements file subset v1" + }, + "extraction": { + "configuration_sha256": "c471ab3438cdba6c5142e03413c15f5d434f9e9bd7fa4ad5e20afbc9252949e2", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-requirements", + "reader_version": "1.0.0", + "support": "partial" + }, + "kind": "dependency", + "native": { + "id": "tree-sitter-rust", + "value": { + "class": "runtime-or-unresolved", + "name": "tree-sitter-rust", + "order": 4, + "requirement": "tree-sitter-rust==0.24.2" + } + }, + "origin": "native", + "projection": { + "loss": "resolution and environment markers not evaluated", + "mapping_version": "requirements-lines@1", + "relation": "depends_on" + }, + "source": { + "content_sha256": "b845de01c1943a4dd9494616548e3997d0a3f11df28265073bd5446fb86ae948", + "file": "msdmd/requirements.txt", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A4", + "identity": "requirement:4", + "scope": "requirements-document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A5/fact/dependency/lines%3A7-7/tree-sitter-java", + "convention": { + "dialect": "requirements", + "namespace": "python.requirements-file", + "version": "PyPA requirements file subset v1" + }, + "extraction": { + "configuration_sha256": "c471ab3438cdba6c5142e03413c15f5d434f9e9bd7fa4ad5e20afbc9252949e2", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-requirements", + "reader_version": "1.0.0", + "support": "partial" + }, + "kind": "dependency", + "native": { + "id": "tree-sitter-java", + "value": { + "class": "runtime-or-unresolved", + "name": "tree-sitter-java", + "order": 5, + "requirement": "tree-sitter-java==0.23.5" + } + }, + "origin": "native", + "projection": { + "loss": "resolution and environment markers not evaluated", + "mapping_version": "requirements-lines@1", + "relation": "depends_on" + }, + "source": { + "content_sha256": "b845de01c1943a4dd9494616548e3997d0a3f11df28265073bd5446fb86ae948", + "file": "msdmd/requirements.txt", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A5", + "identity": "requirement:5", + "scope": "requirements-document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A6/fact/dependency/lines%3A8-8/tree-sitter-c", + "convention": { + "dialect": "requirements", + "namespace": "python.requirements-file", + "version": "PyPA requirements file subset v1" + }, + "extraction": { + "configuration_sha256": "c471ab3438cdba6c5142e03413c15f5d434f9e9bd7fa4ad5e20afbc9252949e2", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-requirements", + "reader_version": "1.0.0", + "support": "partial" + }, + "kind": "dependency", + "native": { + "id": "tree-sitter-c", + "value": { + "class": "runtime-or-unresolved", + "name": "tree-sitter-c", + "order": 6, + "requirement": "tree-sitter-c==0.24.2" + } + }, + "origin": "native", + "projection": { + "loss": "resolution and environment markers not evaluated", + "mapping_version": "requirements-lines@1", + "relation": "depends_on" + }, + "source": { + "content_sha256": "b845de01c1943a4dd9494616548e3997d0a3f11df28265073bd5446fb86ae948", + "file": "msdmd/requirements.txt", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A6", + "identity": "requirement:6", + "scope": "requirements-document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A7/fact/dependency/lines%3A9-9/tree-sitter-cpp", + "convention": { + "dialect": "requirements", + "namespace": "python.requirements-file", + "version": "PyPA requirements file subset v1" + }, + "extraction": { + "configuration_sha256": "c471ab3438cdba6c5142e03413c15f5d434f9e9bd7fa4ad5e20afbc9252949e2", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-requirements", + "reader_version": "1.0.0", + "support": "partial" + }, + "kind": "dependency", + "native": { + "id": "tree-sitter-cpp", + "value": { + "class": "runtime-or-unresolved", + "name": "tree-sitter-cpp", + "order": 7, + "requirement": "tree-sitter-cpp==0.23.4" + } + }, + "origin": "native", + "projection": { + "loss": "resolution and environment markers not evaluated", + "mapping_version": "requirements-lines@1", + "relation": "depends_on" + }, + "source": { + "content_sha256": "b845de01c1943a4dd9494616548e3997d0a3f11df28265073bd5446fb86ae948", + "file": "msdmd/requirements.txt", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/requirements.txt#subject/requirements-document/requirement%3A7", + "identity": "requirement:7", + "scope": "requirements-document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "146:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A284-284/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "146:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 284, + "start_line": 284 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "8:2" + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A284-284/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "8:2" + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 284, + "start_line": 284 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "254:13" + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A284-284/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "254:13" + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 284, + "start_line": 284 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=254:13 imports_exports=8:2 calls_definitions=146:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 73, + "column": 73, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=254:13 imports_exports=8:2 calls_definitions=146:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 284, + "span": { + "end": { + "byte": 18668, + "column": 73, + "line": 284 + }, + "start": { + "byte": 18595, + "column": 0, + "line": 284 + } + }, + "start_line": 284 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::<module>", + "description": "Usage: registry invokes read_standards(path, bytes, context). The JSON/YAML/TOML\nsyntax readers retain unknown fields; this adapter adds source-linked operations,\nschemas, dependency classes, ownership, reported tests and supply-chain subjects.\nThese are extraction subsets, not complete schema validators or attestation\nverifiers. References are retained and diagnosed; no network fetch is performed.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Semantic projections for native metadata documents, preserving owning trees.", + "text": "Semantic projections for native metadata documents, preserving owning trees.\n\nUsage: registry invokes read_standards(path, bytes, context). The JSON/YAML/TOML\nsyntax readers retain unknown fields; this adapter adds source-linked operations,\nschemas, dependency classes, ownership, reported tests and supply-chain subjects.\nThese are extraction subsets, not complete schema validators or attestation\nverifiers. References are retained and diagnosed; no network fetch is performed.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 9, + "span": { + "end": { + "byte": 560, + "column": 3, + "line": 9 + }, + "start": { + "byte": 74, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "base64:base64:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "base64", + "name": "base64" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tomllib:tomllib:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tomllib", + "name": "tomllib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:is_json_schema_uri:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "is_json_schema_uri" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:parse_json:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "parse_json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:parse_yaml:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "parse_yaml" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:parse_xml:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "parse_xml" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/module/msdmd%2Fstandards.py", + "identity": "msdmd/standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/pointer/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "pointer", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:pointer", + "decorators": [], + "kind": "function", + "name": "pointer", + "parent_identity": null, + "qualified_name": "pointer", + "signature": "def pointer(*parts: Any) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 22, + "span": { + "end": { + "byte": 885, + "column": 85, + "line": 22 + }, + "start": { + "byte": 767, + "column": 0, + "line": 21 + } + }, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/pointer", + "identity": "pointer", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.components/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_standards.components", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards.components", + "decorators": [], + "kind": "function", + "name": "components", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards", + "qualified_name": "read_standards.components", + "signature": "def components(items: list, loc: str) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 195, + "span": { + "end": { + "byte": 12032, + "column": 81, + "line": 195 + }, + "start": { + "byte": 11575, + "column": 12, + "line": 190 + } + }, + "start_line": 190 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.components", + "identity": "read_standards.components", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.element_value/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_standards.element_value", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards.element_value", + "decorators": [], + "kind": "function", + "name": "element_value", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards", + "qualified_name": "read_standards.element_value", + "signature": "def element_value(node: Any) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 77, + "span": { + "end": { + "byte": 3606, + "column": 92, + "line": 77 + }, + "start": { + "byte": 3387, + "column": 8, + "line": 75 + } + }, + "start_line": 75 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.element_value", + "identity": "read_standards.element_value", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.emit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_standards.emit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards.emit", + "decorators": [], + "kind": "function", + "name": "emit", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards", + "qualified_name": "read_standards.emit", + "signature": "def emit(convention: str, version: str, kind: str, loc: str, value: Any, *, scope: str='document', identity: str | None=None, native_id: str | None=None, standing: str='declared') -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 43, + "span": { + "end": { + "byte": 1997, + "column": 19, + "line": 43 + }, + "start": { + "byte": 1165, + "column": 4, + "line": 32 + } + }, + "start_line": 32 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.emit", + "identity": "read_standards.emit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.refs/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "leading_trivia", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards.refs", + "metadata_kind": "comment", + "text": "Reference objects are retained, never downloaded or treated as resolved." + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 253, + "span": { + "end": { + "byte": 16879, + "column": 78, + "line": 253 + }, + "start": { + "byte": 16805, + "column": 4, + "line": 253 + } + }, + "start_line": 253 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.refs", + "identity": "read_standards.refs", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.refs/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_standards.refs", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards.refs", + "decorators": [], + "kind": "function", + "name": "refs", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards", + "qualified_name": "read_standards.refs", + "signature": "def refs(item: Any, loc: str) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 265, + "span": { + "end": { + "byte": 17531, + "column": 49, + "line": 265 + }, + "start": { + "byte": 16884, + "column": 4, + "line": 254 + } + }, + "start_line": 254 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.refs", + "identity": "read_standards.refs", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.scrub_xml/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards.scrub_xml", + "metadata_kind": "comment", + "text": "Redact in the XML name domain, before names become generic tag/text keys.\nScrub the parsed tree once so every later semantic projection is safe too." + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 56, + "span": { + "end": { + "byte": 2587, + "column": 88, + "line": 56 + }, + "start": { + "byte": 2423, + "column": 12, + "line": 55 + } + }, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.scrub_xml", + "identity": "read_standards.scrub_xml", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.scrub_xml/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_standards.scrub_xml", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards.scrub_xml", + "decorators": [], + "kind": "function", + "name": "scrub_xml", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards", + "qualified_name": "read_standards.scrub_xml", + "signature": "def scrub_xml(node: Any) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 69, + "span": { + "end": { + "byte": 3110, + "column": 32, + "line": 69 + }, + "start": { + "byte": 2377, + "column": 8, + "line": 54 + } + }, + "start_line": 54 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.scrub_xml", + "identity": "read_standards.scrub_xml", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.unsupported/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_standards.unsupported", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards.unsupported", + "decorators": [], + "kind": "function", + "name": "unsupported", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards", + "qualified_name": "read_standards.unsupported", + "signature": "def unsupported(code: str, message: str, *, status: str='unsupported') -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 46, + "span": { + "end": { + "byte": 2191, + "column": 106, + "line": 46 + }, + "start": { + "byte": 2003, + "column": 4, + "line": 45 + } + }, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.unsupported", + "identity": "read_standards.unsupported", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.walk/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_standards.walk", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards.walk", + "decorators": [], + "kind": "function", + "name": "walk", + "parent_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards", + "qualified_name": "read_standards.walk", + "signature": "def walk(node: Any, loc: str) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 108, + "span": { + "end": { + "byte": 6083, + "column": 61, + "line": 108 + }, + "start": { + "byte": 4501, + "column": 8, + "line": 90 + } + }, + "start_line": 90 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards.walk", + "identity": "read_standards.walk", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards", + "metadata_kind": "comment", + "text": "A structured-document fact is a lossless data view, not standard validation." + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 130, + "span": { + "end": { + "byte": 7199, + "column": 82, + "line": 130 + }, + "start": { + "byte": 7121, + "column": 4, + "line": 130 + } + }, + "start_line": 130 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards", + "identity": "read_standards", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards", + "metadata_kind": "comment", + "text": "Native IDs have convention-owned uniqueness rules; collector pointers do\nnot excuse duplicate IDs. Retain all witnesses while rejecting validity." + } + }, + "origin": "native", + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 268, + "span": { + "end": { + "byte": 17709, + "column": 78, + "line": 268 + }, + "start": { + "byte": 17556, + "column": 4, + "line": 267 + } + }, + "start_line": 267 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards", + "identity": "read_standards", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_standards", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/standards.py::function:read_standards", + "decorators": [], + "kind": "function", + "name": "read_standards", + "parent_identity": null, + "qualified_name": "read_standards", + "signature": "def read_standards(path: Path, data: bytes, context: dict[str, Any]) -> tuple[list, list, list]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 283, + "span": { + "end": { + "byte": 18594, + "column": 36, + "line": 283 + }, + "start": { + "byte": 888, + "column": 0, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards", + "identity": "read_standards", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_fact:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_fact" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards", + "identity": "read_standards", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_diagnostic:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_diagnostic" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards", + "identity": "read_standards", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_edge:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_edge" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards", + "identity": "read_standards", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:_redact_sensitive:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "_redact_sensitive" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7dd1301fa22a8c210142606d5029721910fc3ded1eb73a1966992f4170e3b3bb", + "file": "msdmd/standards.py", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/standards.py#subject/symbol/read_standards", + "identity": "read_standards", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A120-120/calls_definitions", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 120, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A120-120/imports_exports", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 120, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A120-120/loc_comments", + "convention": { + "dialect": "line-comment://", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 120, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/module/msdmd%2Ftypescript-reader.cjs/fact/comment/lines%3A1-1/0", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "0", + "value": { + "attachment": "module-trivia", + "end_line": 1, + "identity": null, + "owner": null, + "start_line": 1, + "text": "// ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/module/msdmd%2Ftypescript-reader.cjs", + "identity": "msdmd/typescript-reader.cjs", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/module/msdmd%2Ftypescript-reader.cjs/fact/comment/lines%3A120-120/5", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "5", + "value": { + "attachment": "module-trivia", + "end_line": 120, + "identity": null, + "owner": null, + "start_line": 120, + "text": "// ratios: loc_comments=hmmm imports_exports=hmmm calls_definitions=hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 120, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/module/msdmd%2Ftypescript-reader.cjs", + "identity": "msdmd/typescript-reader.cjs", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/module/msdmd%2Ftypescript-reader.cjs/fact/comment/lines%3A2-5/1", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "1", + "value": { + "attachment": "module-trivia", + "end_line": 5, + "identity": null, + "owner": null, + "start_line": 2, + "text": "/** Syntax-only worker. Usage: node typescript-reader.cjs < input.json\n * Input: {path, text}; output: version, declarations, imports, exports, docs,\n * lexically owned comments and diagnostics. No target code/config is executed.\n */" + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 5, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/module/msdmd%2Ftypescript-reader.cjs", + "identity": "msdmd/typescript-reader.cjs", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/module/msdmd%2Ftypescript-reader.cjs/fact/comment/lines%3A84-84/3", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "3", + "value": { + "attachment": "module-trivia", + "end_line": 84, + "identity": null, + "owner": null, + "start_line": 84, + "text": "// Token traversal includes trivia before closing braces (even empty bodies)." + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 84, + "start_line": 84 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/module/msdmd%2Ftypescript-reader.cjs", + "identity": "msdmd/typescript-reader.cjs", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/module/msdmd%2Ftypescript-reader.cjs/fact/comment/lines%3A85-85/4", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "4", + "value": { + "attachment": "module-trivia", + "end_line": 85, + "identity": null, + "owner": null, + "start_line": 85, + "text": "// Compiler token boundaries avoid treating strings/templates/regexes as comments." + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 85, + "start_line": 85 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/module/msdmd%2Ftypescript-reader.cjs", + "identity": "msdmd/typescript-reader.cjs", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/binding%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "binding", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 104, + "exported": false, + "identity": "binding#0", + "kind": "VariableDeclaration", + "name": "binding", + "parameters": [], + "qualified_name": "binding", + "returns": null, + "start_line": 104 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 104, + "start_line": 104 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/binding%230", + "identity": "binding#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/collectComments%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "collectComments", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 92, + "exported": false, + "identity": "collectComments#0", + "kind": "FunctionDeclaration", + "name": "collectComments", + "parameters": [ + { + "default": null, + "name": "node", + "optional": false, + "rest": false, + "type": null + } + ], + "qualified_name": "collectComments", + "returns": null, + "start_line": 86 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 92, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/collectComments%230", + "identity": "collectComments#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/collectComments.child%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "collectComments.child", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 91, + "exported": false, + "identity": "collectComments.child#0", + "kind": "VariableDeclaration", + "name": "child", + "parameters": [], + "qualified_name": "collectComments.child", + "returns": null, + "start_line": 91 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 91, + "start_line": 91 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/collectComments.child%230", + "identity": "collectComments.child#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/collectComments.range%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "collectComments.range", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 87, + "exported": false, + "identity": "collectComments.range#0", + "kind": "VariableDeclaration", + "name": "range", + "parameters": [], + "qualified_name": "collectComments.range", + "returns": null, + "start_line": 87 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 87, + "start_line": 87 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/collectComments.range%230", + "identity": "collectComments.range#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/commentRanges%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "commentRanges", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 17, + "exported": false, + "identity": "commentRanges#0", + "kind": "VariableDeclaration", + "name": "commentRanges", + "parameters": [], + "qualified_name": "commentRanges", + "returns": null, + "start_line": 17 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/commentRanges%230", + "identity": "commentRanges#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/counts%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "counts", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 16, + "exported": false, + "identity": "counts#0", + "kind": "VariableDeclaration", + "name": "counts", + "parameters": [], + "qualified_name": "counts", + "returns": null, + "start_line": 16 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/counts%230", + "identity": "counts#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/d%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "d", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 115, + "exported": false, + "identity": "d#0", + "kind": "VariableDeclaration", + "name": "d", + "parameters": [], + "qualified_name": "d", + "returns": null, + "start_line": 115 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 115, + "start_line": 115 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/d%230", + "identity": "d#0", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/declaration%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "declaration", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 110, + "exported": false, + "identity": "declaration#0", + "kind": "VariableDeclaration", + "name": "declaration", + "parameters": [], + "qualified_name": "declaration", + "returns": null, + "start_line": 110 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 110, + "start_line": 110 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/declaration%230", + "identity": "declaration#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/declarationRanges%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "declarationRanges", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 18, + "exported": false, + "identity": "declarationRanges#0", + "kind": "VariableDeclaration", + "name": "declarationRanges", + "parameters": [], + "qualified_name": "declarationRanges", + "returns": null, + "start_line": 18 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/declarationRanges%230", + "identity": "declarationRanges#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/declarations%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "declarations", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 108, + "exported": false, + "identity": "declarations#0", + "kind": "VariableDeclaration", + "name": "declarations", + "parameters": [], + "qualified_name": "declarations", + "returns": null, + "start_line": 106 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 108, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/declarations%230", + "identity": "declarations#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/fs%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "fs", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 7, + "exported": false, + "identity": "fs#0", + "kind": "VariableDeclaration", + "name": "fs", + "parameters": [], + "qualified_name": "fs", + "returns": null, + "start_line": 7 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/fs%230", + "identity": "fs#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/input%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "input", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 9, + "exported": false, + "identity": "input#0", + "kind": "VariableDeclaration", + "name": "input", + "parameters": [], + "qualified_name": "input", + "returns": null, + "start_line": 9 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/input%230", + "identity": "input#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/owner%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "owner", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 97, + "exported": false, + "identity": "owner#0", + "kind": "VariableDeclaration", + "name": "owner", + "parameters": [], + "qualified_name": "owner", + "returns": null, + "start_line": 97 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 97, + "start_line": 97 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/owner%230", + "identity": "owner#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/owners%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "owners", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 95, + "exported": false, + "identity": "owners#0", + "kind": "VariableDeclaration", + "name": "owners", + "parameters": [], + "qualified_name": "owners", + "returns": null, + "start_line": 95 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 95, + "start_line": 95 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/owners%230", + "identity": "owners#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/qualified%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "qualified", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 105, + "exported": false, + "identity": "qualified#0", + "kind": "VariableDeclaration", + "name": "qualified", + "parameters": [], + "qualified_name": "qualified", + "returns": null, + "start_line": 105 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 105, + "start_line": 105 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/qualified%230", + "identity": "qualified#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/qualify%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "qualify", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 19, + "exported": false, + "identity": "qualify#0", + "kind": "VariableDeclaration", + "name": "qualify", + "parameters": [], + "qualified_name": "qualify", + "returns": null, + "start_line": 19 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/qualify%230", + "identity": "qualify#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/range%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "range", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 94, + "exported": false, + "identity": "range#0", + "kind": "VariableDeclaration", + "name": "range", + "parameters": [], + "qualified_name": "range", + "returns": null, + "start_line": 94 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 94, + "start_line": 94 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/range%230", + "identity": "range#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/result%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "result", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 12, + "exported": false, + "identity": "result#0", + "kind": "VariableDeclaration", + "name": "result", + "parameters": [], + "qualified_name": "result", + "returns": null, + "start_line": 12 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/result%230", + "identity": "result#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/sf%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "sf", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 11, + "exported": false, + "identity": "sf#0", + "kind": "VariableDeclaration", + "name": "sf", + "parameters": [], + "qualified_name": "sf", + "returns": null, + "start_line": 11 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/sf%230", + "identity": "sf#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/span%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "span", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 14, + "exported": false, + "identity": "span#0", + "kind": "VariableDeclaration", + "name": "span", + "parameters": [], + "qualified_name": "span", + "returns": null, + "start_line": 13 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 14, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/span%230", + "identity": "span#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/text%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "text", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 15, + "exported": false, + "identity": "text#0", + "kind": "VariableDeclaration", + "name": "text", + "parameters": [], + "qualified_name": "text", + "returns": null, + "start_line": 15 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/text%230", + "identity": "text#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/ts%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "ts", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 8, + "exported": false, + "identity": "ts#0", + "kind": "VariableDeclaration", + "name": "ts", + "parameters": [], + "qualified_name": "ts", + "returns": null, + "start_line": 8 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/ts%230", + "identity": "ts#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit%230/fact/comment/lines%3A49-49/2", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": "2", + "value": { + "attachment": "lexically-enclosing-symbol", + "end_line": 49, + "identity": "visit#0", + "owner": "visit", + "start_line": 49, + "text": "// Collector identity, explicitly not a source name." + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 49, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit%230", + "identity": "visit#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 82, + "exported": false, + "identity": "visit#0", + "kind": "FunctionDeclaration", + "name": "visit", + "parameters": [ + { + "default": null, + "name": "node", + "optional": false, + "rest": false, + "type": null + }, + { + "default": "''", + "name": "owner", + "optional": false, + "rest": false, + "type": null + } + ], + "qualified_name": "visit", + "returns": null, + "start_line": 20 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 82, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit%230", + "identity": "visit#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.anonymousDefault%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.anonymousDefault", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 48, + "exported": false, + "identity": "visit.anonymousDefault#0", + "kind": "VariableDeclaration", + "name": "anonymousDefault", + "parameters": [], + "qualified_name": "visit.anonymousDefault", + "returns": null, + "start_line": 48 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 48, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.anonymousDefault%230", + "identity": "visit.anonymousDefault#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.carrier%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.carrier", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 59, + "exported": false, + "identity": "visit.carrier#0", + "kind": "VariableDeclaration", + "name": "carrier", + "parameters": [], + "qualified_name": "visit.carrier", + "returns": null, + "start_line": 59 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 59, + "start_line": 59 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.carrier%230", + "identity": "visit.carrier#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.declaration%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.declaration", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 66, + "exported": false, + "identity": "visit.declaration#0", + "kind": "VariableDeclaration", + "name": "declaration", + "parameters": [], + "qualified_name": "visit.declaration", + "returns": null, + "start_line": 62 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 66, + "start_line": 62 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.declaration%230", + "identity": "visit.declaration#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.defaultModifier%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.defaultModifier", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 46, + "exported": false, + "identity": "visit.defaultModifier#0", + "kind": "VariableDeclaration", + "name": "defaultModifier", + "parameters": [], + "qualified_name": "visit.defaultModifier", + "returns": null, + "start_line": 46 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 46, + "start_line": 46 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.defaultModifier%230", + "identity": "visit.defaultModifier#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.doc%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.doc", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 74, + "exported": false, + "identity": "visit.doc#0", + "kind": "VariableDeclaration", + "name": "doc", + "parameters": [], + "qualified_name": "visit.doc", + "returns": null, + "start_line": 74 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 74, + "start_line": 74 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.doc%230", + "identity": "visit.doc#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.exported%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.exported", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 61, + "exported": false, + "identity": "visit.exported#0", + "kind": "VariableDeclaration", + "name": "exported", + "parameters": [], + "qualified_name": "visit.exported", + "returns": null, + "start_line": 61 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 61, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.exported%230", + "identity": "visit.exported#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.expression%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.expression", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 34, + "exported": false, + "identity": "visit.expression#0", + "kind": "VariableDeclaration", + "name": "expression", + "parameters": [], + "qualified_name": "visit.expression", + "returns": null, + "start_line": 34 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 34, + "start_line": 34 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.expression%230", + "identity": "visit.expression#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.identity%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.identity", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 58, + "exported": false, + "identity": "visit.identity#0", + "kind": "VariableDeclaration", + "name": "identity", + "parameters": [], + "qualified_name": "visit.identity", + "returns": null, + "start_line": 58 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 58, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.identity%230", + "identity": "visit.identity#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.isDecl%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.isDecl", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 54, + "exported": false, + "identity": "visit.isDecl#0", + "kind": "VariableDeclaration", + "name": "isDecl", + "parameters": [], + "qualified_name": "visit.isDecl", + "returns": null, + "start_line": 51 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 54, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.isDecl%230", + "identity": "visit.isDecl#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.item%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.item", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 26, + "exported": false, + "identity": "visit.item#0", + "kind": "VariableDeclaration", + "name": "item", + "parameters": [], + "qualified_name": "visit.item", + "returns": null, + "start_line": 26 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.item%230", + "identity": "visit.item#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.kind%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.kind", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 50, + "exported": false, + "identity": "visit.kind#0", + "kind": "VariableDeclaration", + "name": "kind", + "parameters": [], + "qualified_name": "visit.kind", + "returns": null, + "start_line": 50 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 50, + "start_line": 50 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.kind%230", + "identity": "visit.kind#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.localOwner%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.localOwner", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 45, + "exported": false, + "identity": "visit.localOwner#0", + "kind": "VariableDeclaration", + "name": "localOwner", + "parameters": [], + "qualified_name": "visit.localOwner", + "returns": null, + "start_line": 45 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 45, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.localOwner%230", + "identity": "visit.localOwner#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.name%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.name", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 47, + "exported": false, + "identity": "visit.name#0", + "kind": "VariableDeclaration", + "name": "name", + "parameters": [], + "qualified_name": "visit.name", + "returns": null, + "start_line": 47 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 47, + "start_line": 47 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.name%230", + "identity": "visit.name#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.ordinal%230/fact/declaration", + "convention": { + "dialect": "typescript-compiler-jsdoc", + "namespace": "typescript.source-metadata", + "version": "5.8.3" + }, + "extraction": { + "configuration_sha256": "5083f18dba5c3d9c8876867a49b7340a54c4e12aa2f6f757868b9b5c1fe4328e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "symbol-declaration", + "native": { + "id": "visit.ordinal", + "value": { + "anonymous": false, + "decorators": [], + "end_line": 57, + "exported": false, + "identity": "visit.ordinal#0", + "kind": "VariableDeclaration", + "name": "ordinal", + "parameters": [], + "qualified_name": "visit.ordinal", + "returns": null, + "start_line": 57 + } + }, + "origin": "native", + "source": { + "content_sha256": "1b05e8ac52f11bda4cfcc17d764a2a1b9a1ff157395c9d5bafeb9e922d139f8e", + "file": "msdmd/typescript-reader.cjs", + "location": { + "end_line": 57, + "start_line": 57 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/typescript-reader.cjs#subject/symbol/visit.ordinal%230", + "identity": "visit.ordinal#0", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "104:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A279-279/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "104:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 279, + "start_line": 279 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "6:3" + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A279-279/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "6:3" + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 279, + "start_line": 279 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "231:15" + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A279-279/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "231:15" + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 279, + "start_line": 279 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=231:15 imports_exports=6:3 calls_definitions=104:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 73, + "column": 73, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "identity": "msdmd/visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=231:15 imports_exports=6:3 calls_definitions=104:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 279, + "span": { + "end": { + "byte": 9831, + "column": 73, + "line": 279 + }, + "start": { + "byte": 9758, + "column": 0, + "line": 279 + } + }, + "start_line": 279 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "identity": "msdmd/visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::<module>", + "description": "The input may be raw JSON, the generated TypeScript shape emitted by\n``msdmd.collect.render_typescript``, or a hand-authored collection point\n(unquoted keys, trailing commas, ``//`` comments, single-quoted strings,\nand the ``ratios:`` seal after the closing ``});`` all parse). This helper\nis intentionally minimal: it visualizes the normalized ``edges`` array from\na ``MsdmdCollection`` and adds gap nodes for visible coverage gaps.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Render an msdmd collection as a small Mermaid relationship graph.", + "text": "Render an msdmd collection as a small Mermaid relationship graph.\n\nThe input may be raw JSON, the generated TypeScript shape emitted by\n``msdmd.collect.render_typescript``, or a hand-authored collection point\n(unquoted keys, trailing commas, ``//`` comments, single-quoted strings,\nand the ``ratios:`` seal after the closing ``});`` all parse). This helper\nis intentionally minimal: it visualizes the normalized ``edges`` array from\na ``MsdmdCollection`` and adds gap nodes for visible coverage gaps.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 10, + "span": { + "end": { + "byte": 581, + "column": 3, + "line": 10 + }, + "start": { + "byte": 74, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "identity": "msdmd/visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "identity": "msdmd/visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "identity": "msdmd/visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "identity": "msdmd/visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "identity": "msdmd/visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "identity": "msdmd/visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/module/msdmd%2Fvisualize.py", + "identity": "msdmd/visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_expand_fact_chunks/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_expand_fact_chunks", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:_expand_fact_chunks", + "decorators": [], + "kind": "function", + "name": "_expand_fact_chunks", + "parent_identity": null, + "qualified_name": "_expand_fact_chunks", + "signature": "def _expand_fact_chunks(text: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 179, + "span": { + "end": { + "byte": 5794, + "column": 23, + "line": 179 + }, + "start": { + "byte": 4214, + "column": 0, + "line": 138 + } + }, + "start_line": 138 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_expand_fact_chunks", + "identity": "_expand_fact_chunks", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_expand_fact_chunks/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:_expand_fact_chunks", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Decode only the generator's literal JSON chunks; never evaluate JS.", + "text": "Decode only the generator's literal JSON chunks; never evaluate JS." + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 139, + "span": { + "end": { + "byte": 4334, + "column": 77, + "line": 139 + }, + "start": { + "byte": 4261, + "column": 4, + "line": 139 + } + }, + "start_line": 139 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_expand_fact_chunks", + "identity": "_expand_fact_chunks", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_extract_payload/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_extract_payload", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:_extract_payload", + "decorators": [], + "kind": "function", + "name": "_extract_payload", + "parent_identity": null, + "qualified_name": "_extract_payload", + "signature": "def _extract_payload(text: str, path: Path) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 85, + "span": { + "end": { + "byte": 2711, + "column": 78, + "line": 85 + }, + "start": { + "byte": 1871, + "column": 0, + "line": 61 + } + }, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_extract_payload", + "identity": "_extract_payload", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_extract_payload/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:_extract_payload", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return the argument of ``defineMsdmdCollection(...)`` in ``text``.", + "text": "Return the argument of ``defineMsdmdCollection(...)`` in ``text``." + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 62, + "span": { + "end": { + "byte": 1999, + "column": 76, + "line": 62 + }, + "start": { + "byte": 1927, + "column": 4, + "line": 62 + } + }, + "start_line": 62 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_extract_payload", + "identity": "_extract_payload", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_label/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_label", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:_label", + "decorators": [], + "kind": "function", + "name": "_label", + "parent_identity": null, + "qualified_name": "_label", + "signature": "def _label(value: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 202, + "span": { + "end": { + "byte": 6583, + "column": 34, + "line": 202 + }, + "start": { + "byte": 6518, + "column": 0, + "line": 201 + } + }, + "start_line": 201 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_label", + "identity": "_label", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_node_id/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_node_id", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:_node_id", + "decorators": [], + "kind": "function", + "name": "_node_id", + "parent_identity": null, + "qualified_name": "_node_id", + "signature": "def _node_id(value: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 198, + "span": { + "end": { + "byte": 6515, + "column": 83, + "line": 198 + }, + "start": { + "byte": 6251, + "column": 0, + "line": 195 + } + }, + "start_line": 195 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_node_id", + "identity": "_node_id", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_node_id/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:_node_id", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return a collision-resistant Mermaid id for a qualified address.", + "text": "Return a collision-resistant Mermaid id for a qualified address." + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 196, + "span": { + "end": { + "byte": 6358, + "column": 74, + "line": 196 + }, + "start": { + "byte": 6288, + "column": 4, + "line": 196 + } + }, + "start_line": 196 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_node_id", + "identity": "_node_id", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_object_literal_to_json/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_object_literal_to_json", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:_object_literal_to_json", + "decorators": [], + "kind": "function", + "name": "_object_literal_to_json", + "parent_identity": null, + "qualified_name": "_object_literal_to_json", + "signature": "def _object_literal_to_json(text: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 4211, + "column": 23, + "line": 135 + }, + "start": { + "byte": 2714, + "column": 0, + "line": 88 + } + }, + "start_line": 88 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_object_literal_to_json", + "identity": "_object_literal_to_json", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_object_literal_to_json/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:_object_literal_to_json", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Convert a comment-free TS/JS object literal to parseable JSON.", + "text": "Convert a comment-free TS/JS object literal to parseable JSON." + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 89, + "span": { + "end": { + "byte": 2833, + "column": 72, + "line": 89 + }, + "start": { + "byte": 2765, + "column": 4, + "line": 89 + } + }, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_object_literal_to_json", + "identity": "_object_literal_to_json", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_strip_comments/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_strip_comments", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:_strip_comments", + "decorators": [], + "kind": "function", + "name": "_strip_comments", + "parent_identity": null, + "qualified_name": "_strip_comments", + "signature": "def _strip_comments(text: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 58, + "span": { + "end": { + "byte": 1868, + "column": 23, + "line": 58 + }, + "start": { + "byte": 913, + "column": 0, + "line": 26 + } + }, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_strip_comments", + "identity": "_strip_comments", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_strip_comments/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:_strip_comments", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Remove ``//`` and ``/* */`` comments outside string literals.", + "text": "Remove ``//`` and ``/* */`` comments outside string literals." + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 27, + "span": { + "end": { + "byte": 1023, + "column": 71, + "line": 27 + }, + "start": { + "byte": 956, + "column": 4, + "line": 27 + } + }, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/_strip_comments", + "identity": "_strip_comments", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/load_collection/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "load_collection", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:load_collection", + "decorators": [], + "kind": "function", + "name": "load_collection", + "parent_identity": null, + "qualified_name": "load_collection", + "signature": "def load_collection(path: Path) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 192, + "span": { + "end": { + "byte": 6248, + "column": 59, + "line": 192 + }, + "start": { + "byte": 5797, + "column": 0, + "line": 182 + } + }, + "start_line": 182 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/load_collection", + "identity": "load_collection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/load_collection/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:load_collection", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Load a collection from JSON, generated, or hand-authored TypeScript.", + "text": "Load a collection from JSON, generated, or hand-authored TypeScript." + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 183, + "span": { + "end": { + "byte": 5916, + "column": 78, + "line": 183 + }, + "start": { + "byte": 5842, + "column": 4, + "line": 183 + } + }, + "start_line": 183 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/load_collection", + "identity": "load_collection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main() -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 274, + "span": { + "end": { + "byte": 9699, + "column": 12, + "line": 274 + }, + "start": { + "byte": 9213, + "column": 0, + "line": 263 + } + }, + "start_line": 263 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/render_mermaid/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "render_mermaid", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:render_mermaid", + "decorators": [], + "kind": "function", + "name": "render_mermaid", + "parent_identity": null, + "qualified_name": "render_mermaid", + "signature": "def render_mermaid(collection: dict) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 260, + "span": { + "end": { + "byte": 9210, + "column": 34, + "line": 260 + }, + "start": { + "byte": 6586, + "column": 0, + "line": 205 + } + }, + "start_line": 205 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/render_mermaid", + "identity": "render_mermaid", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/render_mermaid/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:msdmd/visualize.py::function:render_mermaid", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Render schema-1 or schema-2 ``collection`` as Mermaid flowchart text.", + "text": "Render schema-1 or schema-2 ``collection`` as Mermaid flowchart text." + } + }, + "origin": "native", + "source": { + "content_sha256": "c185c5557aa1e1f3abdc0327bb9ae5e5424db71338c9327e5569cd155e610b11", + "file": "msdmd/visualize.py", + "location": { + "end_line": 206, + "span": { + "end": { + "byte": 6710, + "column": 79, + "line": 206 + }, + "start": { + "byte": 6635, + "column": 4, + "line": 206 + } + }, + "start_line": 206 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/msdmd/visualize.py#subject/symbol/render_mermaid", + "identity": "render_mermaid", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/owner-build/SKILL.md#subject/document/owner-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first module stewardship built on msdmd. Consume provider-specific CODEOWNERS, OWNERS and other authoritative responsibility declarations; supplemental OWNERS blocks express missing stewardship or escalation information. Keep review assignment, operational ownership and permissions distinct. Load this when assigning module ownership, routing reviews, auditing unowned code, or wiring stewardship coverage into CI.", + "name": "owner-build" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "5f690073f9ae89e230e3299f7e018a9ac7ba91c155abd66e8379c39006a0c3ee", + "file": "owner-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/owner-build/SKILL.md#subject/document/owner-build%2FSKILL.md", + "identity": "owner-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/plain-lens/SKILL.md#subject/document/plain-lens%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Building a plain-language, multi-lens companion view of dense canonical text — an easier on-ramp that does not replace or talk down to the source. Load this when you are asked to make an informationally dense document (canon, spec, articles, legal/normative text) easier to approach for newcomers; when building an \"explain it through the lens of X\" selector (domain, audience, or role); when designing progressive-disclosure or layered ELI-not-stupid reading UX; when a dynamic, data-driven site must keep its existing static page as a graceful fallback; or when you need an EDCM-style two-speaker tension reading between a body text and its footnotes/caveats. Use this when the risk is either drowning readers in density or insulting them with oversimplification.", + "name": "plain-lens" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "4c294a959e6858cb06d643c37f2f7ee8d965630ee2370a9d0fbbf1f19ca816cd", + "file": "plain-lens/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/plain-lens/SKILL.md#subject/document/plain-lens%2FSKILL.md", + "identity": "plain-lens/SKILL.md", + "scope": "document" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/project-incubation-graduation/SKILL.md#subject/document/project-incubation-graduation%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Project incubation and graduation doctrine for emergent components born inside an integration, stack, laboratory, or incubator repository. Load this when several existing projects compose into a new candidate capability; when assessing whether that candidate should remain incubated or become its own repository/package; when extracting it with provenance; when establishing a new implementation authority boundary; when publishing the extracted project through a registry such as PyPI; or when making the former incubator consume the released artifact instead of its local copy. Do not load for an ordinary new repository with no incubation history or for a routine package release whose authority boundary is already established.", + "name": "project-incubation-graduation" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "e98961217b2381fc558a5f9024fc73671d4cde74433f29edc2ee88e8de65a586", + "file": "project-incubation-graduation/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/project-incubation-graduation/SKILL.md#subject/document/project-incubation-graduation%2FSKILL.md", + "identity": "project-incubation-graduation/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/SKILL.md#subject/document/ratios%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Self-declaring module composition ratios on msdmd — one comment line at a file's opening and closing source boundaries (never a fenced block), with a valid interpreter shebang allowed before the opening seal. The canonical seal is `The-Interdependency/a0`'s compact positional `N:M C:D I:O` annotation (code:comment · consumed:declared · fan-in:fan-out), computed by a0's `scripts/annotate.py`; the named `loc_comments=… imports_exports=… calls_definitions=…` line is a portable, per-file adaptation for standalone libraries, verified by the stdlib `ratios_check.py` (drift/misplacement failures, visible gaps). JSON/Markdown are out of scope. Load this when recording a module's composition ratios, when authoring or extending the ratio registry, or when wiring ratio verification into CI.", + "name": "ratios" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "c34b06bd6c260f12fedddf67c9aeae80e076bc3d859f674ee451b888cc8fb3c2", + "file": "ratios/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/SKILL.md#subject/document/ratios%2FSKILL.md", + "identity": "ratios/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "124:23" + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A433-433/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "124:23" + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 433, + "start_line": 433 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "7:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A433-433/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "7:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 433, + "start_line": 433 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "324:42" + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A433-433/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "324:42" + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 433, + "start_line": 433 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=324:42 imports_exports=7:5 calls_definitions=124:23" + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 74, + "column": 74, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "identity": "ratios/annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=324:42 imports_exports=7:5 calls_definitions=124:23" + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 433, + "span": { + "end": { + "byte": 14919, + "column": 74, + "line": 433 + }, + "start": { + "byte": 14845, + "column": 0, + "line": 433 + } + }, + "start_line": 433 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "identity": "ratios/annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::<module>", + "description": "This is the shared, stdlib port of `The-Interdependency/a0`'s\n`scripts/annotate.py`. The compact positional line\n\n # N:M C:D I:O (Python)\n // N:M C:D I:O (TypeScript / TSX)\n\nis the *canonical* ratios seal (see `ratios/SKILL.md`). Unlike the portable\nper-file `loc_comments=…` form (verified by `ratios_check.py`), the canonical\n`C:D` and `I:O` are **not single-file computable** — they need a repo-wide\ninverted index. This module builds that index in a single linear pass and can\nrecompute or stamp the seal for any repo, not just a0.\n\nMetric definitions (identical to a0):\n\n N code lines : M comment/docstring lines (internal density)\n C consumed : D declared (surface utility)\n I fan-in : O fan-out (graph position)\n\n D = declared `# DOC endpoint:` routes (.py); exported symbols (.ts/.tsx)\n C = declared routes referenced in the consumer dirs (.py); fan-in (.ts)\n I = repo files that import this module (relative-import stem match)\n O = distinct project-internal modules this file imports (relative imports)\n\nHonest scope note: `C:D` is route/surface-oriented. A pure library that\ndeclares no `# DOC endpoint:` routes and no TS exports reads `C:D = 0:0` — that\nis the correct canonical value, not a gap. Fan-in/out follow a0's relative-\nimport stem graph; modules wired purely by absolute import are not counted\n(that mirrors a0's own annotator). The consumer dirs are the one a0-specific\nbit made configurable here.\n\nPublic API:\n build_index(files, root, *, consumer_dirs=(\"client/src\", \"server\")) -> dict\n build_import_graph(files) -> {adjacency, unresolved, ambiguous}\n seal_line(metrics, marker=\"#\") -> str\n collect_files(root, *, skip=None, extensions=(\".py\",\".ts\",\".tsx\")) -> list[Path]\n\nPure stdlib; safe to copy verbatim into any consuming repo. The import graph\nexposes the same relative-import stem evidence already used for canonical\nfan-in; it does not alter seal computation or invent absolute-import coverage.\nMetric computation self-excludes both compact canonical seals and portable named\n`ratios:` bookends; canonical write/check placement remains compact-only.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Portable computer for the canonical ratios seal — a0's `N:M C:D I:O`.", + "text": "Portable computer for the canonical ratios seal — a0's `N:M C:D I:O`.\n\nThis is the shared, stdlib port of `The-Interdependency/a0`'s\n`scripts/annotate.py`. The compact positional line\n\n # N:M C:D I:O (Python)\n // N:M C:D I:O (TypeScript / TSX)\n\nis the *canonical* ratios seal (see `ratios/SKILL.md`). Unlike the portable\nper-file `loc_comments=…` form (verified by `ratios_check.py`), the canonical\n`C:D` and `I:O` are **not single-file computable** — they need a repo-wide\ninverted index. This module builds that index in a single linear pass and can\nrecompute or stamp the seal for any repo, not just a0.\n\nMetric definitions (identical to a0):\n\n N code lines : M comment/docstring lines (internal density)\n C consumed : D declared (surface utility)\n I fan-in : O fan-out (graph position)\n\n D = declared `# DOC endpoint:` routes (.py); exported symbols (.ts/.tsx)\n C = declared routes referenced in the consumer dirs (.py); fan-in (.ts)\n I = repo files that import this module (relative-import stem match)\n O = distinct project-internal modules this file imports (relative imports)\n\nHonest scope note: `C:D` is route/surface-oriented. A pure library that\ndeclares no `# DOC endpoint:` routes and no TS exports reads `C:D = 0:0` — that\nis the correct canonical value, not a gap. Fan-in/out follow a0's relative-\nimport stem graph; modules wired purely by absolute import are not counted\n(that mirrors a0's own annotator). The consumer dirs are the one a0-specific\nbit made configurable here.\n\nPublic API:\n build_index(files, root, *, consumer_dirs=(\"client/src\", \"server\")) -> dict\n build_import_graph(files) -> {adjacency, unresolved, ambiguous}\n seal_line(metrics, marker=\"#\") -> str\n collect_files(root, *, skip=None, extensions=(\".py\",\".ts\",\".tsx\")) -> list[Path]\n\nPure stdlib; safe to copy verbatim into any consuming repo. The import graph\nexposes the same relative-import stem evidence already used for canonical\nfan-in; it does not alter seal computation or invent absolute-import coverage.\nMetric computation self-excludes both compact canonical seals and portable named\n`ratios:` bookends; canonical write/check placement remains compact-only.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 45, + "span": { + "end": { + "byte": 2375, + "column": 3, + "line": 45 + }, + "start": { + "byte": 75, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "identity": "ratios/annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 46, + "start_line": 46 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "identity": "ratios/annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 47, + "start_line": 47 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "identity": "ratios/annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 48, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "identity": "ratios/annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 49, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "identity": "ratios/annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterable:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 50, + "start_line": 50 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/module/ratios%2Fannotate_index.py", + "identity": "ratios/annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_count_python/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_count_python", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_count_python", + "decorators": [], + "kind": "function", + "name": "_count_python", + "parent_identity": null, + "qualified_name": "_count_python", + "signature": "def _count_python(lines: list[str]) -> tuple[int, int]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 139, + "span": { + "end": { + "byte": 5235, + "column": 24, + "line": 139 + }, + "start": { + "byte": 4608, + "column": 0, + "line": 117 + } + }, + "start_line": 117 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_count_python", + "identity": "_count_python", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_count_ts/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_count_ts", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_count_ts", + "decorators": [], + "kind": "function", + "name": "_count_ts", + "parent_identity": null, + "qualified_name": "_count_ts", + "signature": "def _count_ts(lines: list[str]) -> tuple[int, int]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 161, + "span": { + "end": { + "byte": 5768, + "column": 24, + "line": 161 + }, + "start": { + "byte": 5238, + "column": 0, + "line": 142 + } + }, + "start_line": 142 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_count_ts", + "identity": "_count_ts", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_has_valid_shebang/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_has_valid_shebang", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_has_valid_shebang", + "decorators": [], + "kind": "function", + "name": "_has_valid_shebang", + "parent_identity": null, + "qualified_name": "_has_valid_shebang", + "signature": "def _has_valid_shebang(lines: list[str]) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 80, + "span": { + "end": { + "byte": 3579, + "column": 77, + "line": 80 + }, + "start": { + "byte": 3374, + "column": 0, + "line": 78 + } + }, + "start_line": 78 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_has_valid_shebang", + "identity": "_has_valid_shebang", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_has_valid_shebang/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_has_valid_shebang", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return whether literal line 1 is a non-empty interpreter directive.", + "text": "Return whether literal line 1 is a non-empty interpreter directive." + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 79, + "span": { + "end": { + "byte": 3501, + "column": 77, + "line": 79 + }, + "start": { + "byte": 3428, + "column": 4, + "line": 79 + } + }, + "start_line": 79 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_has_valid_shebang", + "identity": "_has_valid_shebang", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_import_evidence/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_import_evidence", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_import_evidence", + "decorators": [], + "kind": "function", + "name": "_import_evidence", + "parent_identity": null, + "qualified_name": "_import_evidence", + "signature": "def _import_evidence(files: list[Path], texts: dict[str, str]) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 282, + "span": { + "end": { + "byte": 9595, + "column": 5, + "line": 282 + }, + "start": { + "byte": 8344, + "column": 0, + "line": 250 + } + }, + "start_line": 250 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_import_evidence", + "identity": "_import_evidence", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_imported_stems/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_imported_stems", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_imported_stems", + "decorators": [], + "kind": "function", + "name": "_imported_stems", + "parent_identity": null, + "qualified_name": "_imported_stems", + "signature": "def _imported_stems(text: str, ext: str) -> set[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 247, + "span": { + "end": { + "byte": 8341, + "column": 16, + "line": 247 + }, + "start": { + "byte": 7546, + "column": 0, + "line": 229 + } + }, + "start_line": 229 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_imported_stems", + "identity": "_imported_stems", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_imported_stems/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_imported_stems", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return relative-import terminal stems using canonical fan-in semantics.", + "text": "Return relative-import terminal stems using canonical fan-in semantics." + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 230, + "span": { + "end": { + "byte": 7681, + "column": 81, + "line": 230 + }, + "start": { + "byte": 7604, + "column": 4, + "line": 230 + } + }, + "start_line": 230 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_imported_stems", + "identity": "_imported_stems", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_is_named_seal/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_is_named_seal", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_is_named_seal", + "decorators": [], + "kind": "function", + "name": "_is_named_seal", + "parent_identity": null, + "qualified_name": "_is_named_seal", + "signature": "def _is_named_seal(line: str) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 75, + "span": { + "end": { + "byte": 3371, + "column": 47, + "line": 75 + }, + "start": { + "byte": 3209, + "column": 0, + "line": 73 + } + }, + "start_line": 73 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_is_named_seal", + "identity": "_is_named_seal", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_is_named_seal/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_is_named_seal", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return whether a line is the portable named RATIOS boundary seal.", + "text": "Return whether a line is the portable named RATIOS boundary seal." + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 74, + "span": { + "end": { + "byte": 3323, + "column": 75, + "line": 74 + }, + "start": { + "byte": 3252, + "column": 4, + "line": 74 + } + }, + "start_line": 74 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_is_named_seal", + "identity": "_is_named_seal", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_is_seal/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_is_seal", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_is_seal", + "decorators": [], + "kind": "function", + "name": "_is_seal", + "parent_identity": null, + "qualified_name": "_is_seal", + "signature": "def _is_seal(line: str, ext: str) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 70, + "span": { + "end": { + "byte": 3206, + "column": 64, + "line": 70 + }, + "start": { + "byte": 3078, + "column": 0, + "line": 68 + } + }, + "start_line": 68 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_is_seal", + "identity": "_is_seal", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_last_nonblank_index/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_last_nonblank_index", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_last_nonblank_index", + "decorators": [], + "kind": "function", + "name": "_last_nonblank_index", + "parent_identity": null, + "qualified_name": "_last_nonblank_index", + "signature": "def _last_nonblank_index(lines: list[str]) -> int | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 91, + "span": { + "end": { + "byte": 3857, + "column": 15, + "line": 91 + }, + "start": { + "byte": 3678, + "column": 0, + "line": 87 + } + }, + "start_line": 87 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_last_nonblank_index", + "identity": "_last_nonblank_index", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_marker_for/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_marker_for", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_marker_for", + "decorators": [], + "kind": "function", + "name": "_marker_for", + "parent_identity": null, + "qualified_name": "_marker_for", + "signature": "def _marker_for(ext: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 369, + "span": { + "end": { + "byte": 12599, + "column": 65, + "line": 369 + }, + "start": { + "byte": 12500, + "column": 0, + "line": 368 + } + }, + "start_line": 368 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_marker_for", + "identity": "_marker_for", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_opening_index/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_opening_index", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_opening_index", + "decorators": [], + "kind": "function", + "name": "_opening_index", + "parent_identity": null, + "qualified_name": "_opening_index", + "signature": "def _opening_index(lines: list[str]) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 84, + "span": { + "end": { + "byte": 3675, + "column": 48, + "line": 84 + }, + "start": { + "byte": 3582, + "column": 0, + "line": 83 + } + }, + "start_line": 83 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_opening_index", + "identity": "_opening_index", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_py_endpoints/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_py_endpoints", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_py_endpoints", + "decorators": [], + "kind": "function", + "name": "_py_endpoints", + "parent_identity": null, + "qualified_name": "_py_endpoints", + "signature": "def _py_endpoints(lines: list[str]) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 170, + "span": { + "end": { + "byte": 6011, + "column": 16, + "line": 170 + }, + "start": { + "byte": 5771, + "column": 0, + "line": 164 + } + }, + "start_line": 164 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_py_endpoints", + "identity": "_py_endpoints", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_py_fanout/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_py_fanout", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_py_fanout", + "decorators": [], + "kind": "function", + "name": "_py_fanout", + "parent_identity": null, + "qualified_name": "_py_fanout", + "signature": "def _py_fanout(lines: list[str]) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 179, + "span": { + "end": { + "byte": 6233, + "column": 20, + "line": 179 + }, + "start": { + "byte": 6014, + "column": 0, + "line": 173 + } + }, + "start_line": 173 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_py_fanout", + "identity": "_py_fanout", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_read_consumer_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_consumer_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_read_consumer_text", + "decorators": [], + "kind": "function", + "name": "_read_consumer_text", + "parent_identity": null, + "qualified_name": "_read_consumer_text", + "signature": "def _read_consumer_text(root: Path, consumer_dirs: Iterable[str]) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 216, + "span": { + "end": { + "byte": 7277, + "column": 27, + "line": 216 + }, + "start": { + "byte": 6816, + "column": 0, + "line": 204 + } + }, + "start_line": 204 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_read_consumer_text", + "identity": "_read_consumer_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_read_texts/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_read_texts", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_read_texts", + "decorators": [], + "kind": "function", + "name": "_read_texts", + "parent_identity": null, + "qualified_name": "_read_texts", + "signature": "def _read_texts(files: Iterable[Path]) -> dict[str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 226, + "span": { + "end": { + "byte": 7543, + "column": 16, + "line": 226 + }, + "start": { + "byte": 7280, + "column": 0, + "line": 219 + } + }, + "start_line": 219 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_read_texts", + "identity": "_read_texts", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_strip_measurement_seals/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_strip_measurement_seals", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_strip_measurement_seals", + "decorators": [], + "kind": "function", + "name": "_strip_measurement_seals", + "parent_identity": null, + "qualified_name": "_strip_measurement_seals", + "signature": "def _strip_measurement_seals(lines: list[str], ext: str) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 114, + "span": { + "end": { + "byte": 4605, + "column": 12, + "line": 114 + }, + "start": { + "byte": 4179, + "column": 0, + "line": 105 + } + }, + "start_line": 105 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_strip_measurement_seals", + "identity": "_strip_measurement_seals", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_strip_measurement_seals/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_strip_measurement_seals", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Exclude compact or named boundary seals from metric computation only.", + "text": "Exclude compact or named boundary seals from metric computation only." + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 106, + "span": { + "end": { + "byte": 4329, + "column": 79, + "line": 106 + }, + "start": { + "byte": 4254, + "column": 4, + "line": 106 + } + }, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_strip_measurement_seals", + "identity": "_strip_measurement_seals", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_strip_seal/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_strip_seal", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_strip_seal", + "decorators": [], + "kind": "function", + "name": "_strip_seal", + "parent_identity": null, + "qualified_name": "_strip_seal", + "signature": "def _strip_seal(lines: list[str], ext: str) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 102, + "span": { + "end": { + "byte": 4176, + "column": 12, + "line": 102 + }, + "start": { + "byte": 3860, + "column": 0, + "line": 94 + } + }, + "start_line": 94 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_strip_seal", + "identity": "_strip_seal", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_ts_declared/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_ts_declared", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_ts_declared", + "decorators": [], + "kind": "function", + "name": "_ts_declared", + "parent_identity": null, + "qualified_name": "_ts_declared", + "signature": "def _ts_declared(lines: list[str]) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 192, + "span": { + "end": { + "byte": 6572, + "column": 16, + "line": 192 + }, + "start": { + "byte": 6236, + "column": 0, + "line": 182 + } + }, + "start_line": 182 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_ts_declared", + "identity": "_ts_declared", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_ts_fanout/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_ts_fanout", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:_ts_fanout", + "decorators": [], + "kind": "function", + "name": "_ts_fanout", + "parent_identity": null, + "qualified_name": "_ts_fanout", + "signature": "def _ts_fanout(lines: list[str]) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 201, + "span": { + "end": { + "byte": 6813, + "column": 20, + "line": 201 + }, + "start": { + "byte": 6575, + "column": 0, + "line": 195 + } + }, + "start_line": 195 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/_ts_fanout", + "identity": "_ts_fanout", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/build_import_graph/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "build_import_graph", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:build_import_graph", + "decorators": [], + "kind": "function", + "name": "build_import_graph", + "parent_identity": null, + "qualified_name": "build_import_graph", + "signature": "def build_import_graph(files: list[Path]) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 293, + "span": { + "end": { + "byte": 10013, + "column": 5, + "line": 293 + }, + "start": { + "byte": 9598, + "column": 0, + "line": 285 + } + }, + "start_line": 285 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/build_import_graph", + "identity": "build_import_graph", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/build_import_graph/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:build_import_graph", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Expose the canonical relative-import stem graph without changing seals.", + "text": "Expose the canonical relative-import stem graph without changing seals." + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 286, + "span": { + "end": { + "byte": 9730, + "column": 81, + "line": 286 + }, + "start": { + "byte": 9653, + "column": 4, + "line": 286 + } + }, + "start_line": 286 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/build_import_graph", + "identity": "build_import_graph", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/build_index/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "build_index", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:build_index", + "decorators": [], + "kind": "function", + "name": "build_index", + "parent_identity": null, + "qualified_name": "build_index", + "signature": "def build_index(files: list[Path], root: Path, *, consumer_dirs: Iterable[str]=DEFAULT_CONSUMER_DIRS) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 338, + "span": { + "end": { + "byte": 11621, + "column": 16, + "line": 338 + }, + "start": { + "byte": 10016, + "column": 0, + "line": 296 + } + }, + "start_line": 296 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/build_index", + "identity": "build_index", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/build_index/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:build_index", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Compute N:M C:D I:O for every file. Fan-in via one inverted-index pass.", + "text": "Compute N:M C:D I:O for every file. Fan-in via one inverted-index pass." + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 302, + "span": { + "end": { + "byte": 10229, + "column": 81, + "line": 302 + }, + "start": { + "byte": 10152, + "column": 4, + "line": 302 + } + }, + "start_line": 302 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/build_index", + "identity": "build_index", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/collect_files/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "collect_files", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:collect_files", + "decorators": [], + "kind": "function", + "name": "collect_files", + "parent_identity": null, + "qualified_name": "collect_files", + "signature": "def collect_files(root: Path, *, skip: Iterable[str] | None=None, extensions: Iterable[str]=('.py', '.ts', '.tsx')) -> list[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 365, + "span": { + "end": { + "byte": 12497, + "column": 22, + "line": 365 + }, + "start": { + "byte": 11948, + "column": 0, + "line": 350 + } + }, + "start_line": 350 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/collect_files", + "identity": "collect_files", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: list[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 428, + "span": { + "end": { + "byte": 14786, + "column": 12, + "line": 428 + }, + "start": { + "byte": 12602, + "column": 0, + "line": 372 + } + }, + "start_line": 372 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/main/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 373, + "start_line": 373 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/seal_line/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "seal_line", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:seal_line", + "decorators": [], + "kind": "function", + "name": "seal_line", + "parent_identity": null, + "qualified_name": "seal_line", + "signature": "def seal_line(metrics: dict, marker: str='#') -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 347, + "span": { + "end": { + "byte": 11945, + "column": 5, + "line": 347 + }, + "start": { + "byte": 11624, + "column": 0, + "line": 341 + } + }, + "start_line": 341 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/seal_line", + "identity": "seal_line", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/seal_line/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/annotate_index.py::function:seal_line", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Render the canonical `N:M C:D I:O` seal line for one file's metrics.", + "text": "Render the canonical `N:M C:D I:O` seal line for one file's metrics." + } + }, + "origin": "native", + "source": { + "content_sha256": "f59536a0a7bcb7e0f0f77d59aa67f5e934956d1245d8e65c1e80b1d2aabae21c", + "file": "ratios/annotate_index.py", + "location": { + "end_line": 342, + "span": { + "end": { + "byte": 11758, + "column": 78, + "line": 342 + }, + "start": { + "byte": 11684, + "column": 4, + "line": 342 + } + }, + "start_line": 342 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/annotate_index.py#subject/symbol/seal_line", + "identity": "seal_line", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "96:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A298-298/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "96:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 298, + "start_line": 298 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "5:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A298-298/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "5:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 298, + "start_line": 298 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "230:30" + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A298-298/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "230:30" + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 298, + "start_line": 298 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=230:30 imports_exports=5:4 calls_definitions=96:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 73, + "column": 73, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "identity": "ratios/harmonic_math.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: ratios_harmonic_math\n module_name: harmonic_math\n module_kind: experiment\n summary: supplies dependency-free graph and scalar harmonic estimators for ratio exploration\n owner: The Interdependency\n public_surface: graph_harmonics, harmonic_scan\n internal_surface: Jacobi eigensolver, eigenspace grouping, sinusoid least-squares fit\n auth_boundary: none\n storage_boundary: none\n network_boundary: none\n user_data_boundary: none\n admin_only: false\n tests: tests/test_harmonics.py\n rollout: imported only by the opt-in ratios harmonic explorer\n rollback: remove this helper with ratios/harmonics.py; no stored state exists\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 34, + "span": { + "end": { + "byte": 1291, + "column": 26, + "line": 34 + }, + "start": { + "byte": 575, + "column": 0, + "line": 18 + } + }, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "identity": "ratios/harmonic_math.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=230:30 imports_exports=5:4 calls_definitions=96:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 298, + "span": { + "end": { + "byte": 10778, + "column": 73, + "line": 298 + }, + "start": { + "byte": 10705, + "column": 0, + "line": 298 + } + }, + "start_line": 298 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "identity": "ratios/harmonic_math.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::<module>", + "description": "Usage:\n from harmonic_math import graph_harmonics, harmonic_scan\n\n`graph_harmonics` analyzes a signal on a graph Laplacian and sums spectral\nenergy across degenerate eigenspaces before permutation testing.\n`harmonic_scan` fits sin/cos pairs at integer harmonics of a scalar axis span.\nNeither function interprets msdmd or mutates source files.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Pure-stdlib harmonic math used by ratios/harmonics.py.", + "text": "Pure-stdlib harmonic math used by ratios/harmonics.py.\n\nUsage:\n from harmonic_math import graph_harmonics, harmonic_scan\n\n`graph_harmonics` analyzes a signal on a graph Laplacian and sums spectral\nenergy across degenerate eigenspaces before permutation testing.\n`harmonic_scan` fits sin/cos pairs at integer harmonics of a scalar axis span.\nNeither function interprets msdmd or mutates source files.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 11, + "span": { + "end": { + "byte": 483, + "column": 3, + "line": 11 + }, + "start": { + "byte": 74, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "identity": "ratios/harmonic_math.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "identity": "ratios/harmonic_math.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "math:math:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "math", + "name": "math" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "identity": "ratios/harmonic_math.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "random:random:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "random", + "name": "random" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "identity": "ratios/harmonic_math.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterable:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/module/ratios%2Fharmonic_math.py", + "identity": "ratios/harmonic_math.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_dot/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_dot", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:_dot", + "decorators": [], + "kind": "function", + "name": "_dot", + "parent_identity": null, + "qualified_name": "_dot", + "signature": "def _dot(left: list[float], right: list[float]) -> float" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 149, + "span": { + "end": { + "byte": 5273, + "column": 50, + "line": 149 + }, + "start": { + "byte": 5165, + "column": 0, + "line": 148 + } + }, + "start_line": 148 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_dot", + "identity": "_dot", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_eigen_groups/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_eigen_groups", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:_eigen_groups", + "decorators": [], + "kind": "function", + "name": "_eigen_groups", + "parent_identity": null, + "qualified_name": "_eigen_groups", + "signature": "def _eigen_groups(values: list[float], *, tol: float=1e-08) -> list[list[int]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 145, + "span": { + "end": { + "byte": 5162, + "column": 17, + "line": 145 + }, + "start": { + "byte": 4696, + "column": 0, + "line": 133 + } + }, + "start_line": 133 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_eigen_groups", + "identity": "_eigen_groups", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_jacobi_eigh/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_jacobi_eigh", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:_jacobi_eigh", + "decorators": [], + "kind": "function", + "name": "_jacobi_eigh", + "parent_identity": null, + "qualified_name": "_jacobi_eigh", + "signature": "def _jacobi_eigh(matrix: list[list[float]], *, tol: float=1e-11, max_sweeps: int=60) -> tuple[list[float], list[list[float]]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 130, + "span": { + "end": { + "byte": 4693, + "column": 26, + "line": 130 + }, + "start": { + "byte": 2574, + "column": 0, + "line": 72 + } + }, + "start_line": 72 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_jacobi_eigh", + "identity": "_jacobi_eigh", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_jacobi_eigh/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:_jacobi_eigh", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Eigenpairs for a real symmetric matrix using cyclic Jacobi rotations.", + "text": "Eigenpairs for a real symmetric matrix using cyclic Jacobi rotations." + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 78, + "span": { + "end": { + "byte": 2803, + "column": 79, + "line": 78 + }, + "start": { + "byte": 2728, + "column": 4, + "line": 78 + } + }, + "start_line": 78 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_jacobi_eigh", + "identity": "_jacobi_eigh", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_laplacian/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_laplacian", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:_laplacian", + "decorators": [], + "kind": "function", + "name": "_laplacian", + "parent_identity": null, + "qualified_name": "_laplacian", + "signature": "def _laplacian(nodes: list[str], graph: dict[str, set[str]]) -> list[list[float]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 69, + "span": { + "end": { + "byte": 2571, + "column": 17, + "line": 69 + }, + "start": { + "byte": 2124, + "column": 0, + "line": 60 + } + }, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_laplacian", + "identity": "_laplacian", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_sinusoid_power/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_sinusoid_power", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:_sinusoid_power", + "decorators": [], + "kind": "function", + "name": "_sinusoid_power", + "parent_identity": null, + "qualified_name": "_sinusoid_power", + "signature": "def _sinusoid_power(x: list[float], y: list[float], omega: float) -> float" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 257, + "span": { + "end": { + "byte": 9332, + "column": 46, + "line": 257 + }, + "start": { + "byte": 8420, + "column": 0, + "line": 237 + } + }, + "start_line": 237 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_sinusoid_power", + "identity": "_sinusoid_power", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_solve3/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_solve3", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:_solve3", + "decorators": [], + "kind": "function", + "name": "_solve3", + "parent_identity": null, + "qualified_name": "_solve3", + "signature": "def _solve3(matrix: list[list[float]], rhs: list[float]) -> list[float] | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 234, + "span": { + "end": { + "byte": 8417, + "column": 40, + "line": 234 + }, + "start": { + "byte": 7723, + "column": 0, + "line": 219 + } + }, + "start_line": 219 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_solve3", + "identity": "_solve3", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_undirected/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_undirected", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:_undirected", + "decorators": [], + "kind": "function", + "name": "_undirected", + "parent_identity": null, + "qualified_name": "_undirected", + "signature": "def _undirected(adjacency: dict[str, Iterable[str]], nodes: Iterable[str]) -> dict[str, set[str]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 47, + "span": { + "end": { + "byte": 1721, + "column": 16, + "line": 47 + }, + "start": { + "byte": 1294, + "column": 0, + "line": 37 + } + }, + "start_line": 37 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/_undirected", + "identity": "_undirected", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/active_nodes/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "active_nodes", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:active_nodes", + "decorators": [], + "kind": "function", + "name": "active_nodes", + "parent_identity": null, + "qualified_name": "active_nodes", + "signature": "def active_nodes(graph: dict[str, set[str]]) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 52, + "span": { + "end": { + "byte": 1909, + "column": 73, + "line": 52 + }, + "start": { + "byte": 1724, + "column": 0, + "line": 50 + } + }, + "start_line": 50 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/active_nodes", + "identity": "active_nodes", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/active_nodes/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:active_nodes", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return graph nodes with at least one edge.", + "text": "Return graph nodes with at least one edge." + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 51, + "span": { + "end": { + "byte": 1835, + "column": 52, + "line": 51 + }, + "start": { + "byte": 1787, + "column": 4, + "line": 51 + } + }, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/active_nodes", + "identity": "active_nodes", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/graph_harmonics/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "graph_harmonics", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:graph_harmonics", + "decorators": [], + "kind": "function", + "name": "graph_harmonics", + "parent_identity": null, + "qualified_name": "graph_harmonics", + "signature": "def graph_harmonics(adjacency: dict[str, Iterable[str]], signal: dict[str, float], *, permutations: int=199, seed: int=0, max_nodes: int=128) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 216, + "span": { + "end": { + "byte": 7720, + "column": 5, + "line": 216 + }, + "start": { + "byte": 5276, + "column": 0, + "line": 152 + } + }, + "start_line": 152 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/graph_harmonics", + "identity": "graph_harmonics", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/graph_harmonics/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:graph_harmonics", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Project a node signal onto Laplacian eigenspaces with a permutation null.", + "text": "Project a node signal onto Laplacian eigenspaces with a permutation null." + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 160, + "span": { + "end": { + "byte": 5543, + "column": 83, + "line": 160 + }, + "start": { + "byte": 5464, + "column": 4, + "line": 160 + } + }, + "start_line": 160 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/graph_harmonics", + "identity": "graph_harmonics", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/harmonic_scan/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "harmonic_scan", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:harmonic_scan", + "decorators": [], + "kind": "function", + "name": "harmonic_scan", + "parent_identity": null, + "qualified_name": "harmonic_scan", + "signature": "def harmonic_scan(x: list[float], y: list[float], *, max_harmonic: int=12, permutations: int=199, seed: int=0) -> list[dict]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 297, + "span": { + "end": { + "byte": 10704, + "column": 5, + "line": 297 + }, + "start": { + "byte": 9335, + "column": 0, + "line": 260 + } + }, + "start_line": 260 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/harmonic_scan", + "identity": "harmonic_scan", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/harmonic_scan/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:harmonic_scan", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Least-squares sin/cos scan over integer harmonics of the observed span.", + "text": "Least-squares sin/cos scan over integer harmonics of the observed span." + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 268, + "span": { + "end": { + "byte": 9575, + "column": 81, + "line": 268 + }, + "start": { + "byte": 9498, + "column": 4, + "line": 268 + } + }, + "start_line": 268 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/harmonic_scan", + "identity": "harmonic_scan", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/undirected_graph/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "undirected_graph", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:undirected_graph", + "decorators": [], + "kind": "function", + "name": "undirected_graph", + "parent_identity": null, + "qualified_name": "undirected_graph", + "signature": "def undirected_graph(adjacency: dict[str, Iterable[str]], nodes: Iterable[str]) -> dict[str, set[str]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 57, + "span": { + "end": { + "byte": 2121, + "column": 40, + "line": 57 + }, + "start": { + "byte": 1912, + "column": 0, + "line": 55 + } + }, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/undirected_graph", + "identity": "undirected_graph", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/undirected_graph/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonic_math.py::function:undirected_graph", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Public wrapper for the undirected analysis projection.", + "text": "Public wrapper for the undirected analysis projection." + } + }, + "origin": "native", + "source": { + "content_sha256": "0fc1bfea48f320775514e3029d945ab4b21e73933f802a06a8aa23e0248183a4", + "file": "ratios/harmonic_math.py", + "location": { + "end_line": 56, + "span": { + "end": { + "byte": 2080, + "column": 64, + "line": 56 + }, + "start": { + "byte": 2020, + "column": 4, + "line": 56 + } + }, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonic_math.py#subject/symbol/undirected_graph", + "identity": "undirected_graph", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "119:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A354-354/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "119:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 354, + "start_line": 354 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "10:8" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A354-354/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "10:8" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 354, + "start_line": 354 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "276:33" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A354-354/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "276:33" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 354, + "start_line": 354 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=276:33 imports_exports=10:8 calls_definitions=119:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 75, + "column": 75, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: ratios_harmonic_explorer\n module_name: harmonics\n module_kind: experiment\n summary: explores harmonic structure of verified ratio primitives over non-time domains\n owner: The Interdependency\n public_surface: semantic_file_graph, source_balance_series, analyze, main\n internal_surface: graph preparation, metric selection, distance projection, report rendering\n auth_boundary: none\n storage_boundary: read\n network_boundary: none\n user_data_boundary: none\n admin_only: false\n tests: tests/test_harmonics.py\n rollout: opt-in read-only CLI; never a compliance gate\n rollback: remove ratios/harmonics.py and harmonic_math.py; RATIOS seals remain unchanged\n requires: ratios_harmonic_math\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 42, + "span": { + "end": { + "byte": 1734, + "column": 26, + "line": 42 + }, + "start": { + "byte": 950, + "column": 0, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::<module>", + "metadata_kind": "comment", + "text": "noqa: E402" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 48, + "span": { + "end": { + "byte": 1880, + "column": 40, + "line": 48 + }, + "start": { + "byte": 1868, + "column": 28, + "line": 48 + } + }, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::<module>", + "metadata_kind": "comment", + "text": "noqa: E402" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 49, + "span": { + "end": { + "byte": 1922, + "column": 41, + "line": 49 + }, + "start": { + "byte": 1910, + "column": 29, + "line": 49 + } + }, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=276:33 imports_exports=10:8 calls_definitions=119:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 354, + "span": { + "end": { + "byte": 15312, + "column": 75, + "line": 354 + }, + "start": { + "byte": 15237, + "column": 0, + "line": 354 + } + }, + "start_line": 354 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::<module>", + "description": "Usage:\n python ratios/harmonics.py --root . --domain import --signal code\n python ratios/harmonics.py --root . --domain semantic --signal fan_in\n python ratios/harmonics.py --root . --domain distance --anchor pkg/api.py\n python ratios/harmonics.py --root . --domain source --file pkg/api.py\n python ratios/harmonics.py --root . --domain import --signal code --json\n\nGraph domains use Laplacian eigenspaces; scalar domains use least-squares\nsin/cos harmonics. Every reported peak can be compared to a deterministic\npermutation null. This module is read-only research instrumentation, never a\nRATIOS compliance gate.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Explore harmonic structure in msdmd RATIOS without changing the RATIOS seal.", + "text": "Explore harmonic structure in msdmd RATIOS without changing the RATIOS seal.\n\nUsage:\n python ratios/harmonics.py --root . --domain import --signal code\n python ratios/harmonics.py --root . --domain semantic --signal fan_in\n python ratios/harmonics.py --root . --domain distance --anchor pkg/api.py\n python ratios/harmonics.py --root . --domain source --file pkg/api.py\n python ratios/harmonics.py --root . --domain import --signal code --json\n\nGraph domains use Laplacian eigenspaces; scalar domains use least-squares\nsin/cos harmonics. Every reported peak can be compared to a deterministic\npermutation null. This module is read-only research instrumentation, never a\nRATIOS compliance gate.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 15, + "span": { + "end": { + "byte": 790, + "column": 3, + "line": 15 + }, + "start": { + "byte": 76, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "harmonic_math:harmonic_scan:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "harmonic_math", + "name": "harmonic_scan" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 54, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "harmonic_math:undirected_graph:11", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "harmonic_math", + "name": "undirected_graph" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 54, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "collections:deque:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "collections", + "name": "deque" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterable:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 23, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "annotate_index:annotate_index:7", + "value": { + "alias": "A", + "kind": "import", + "level": 0, + "module": "annotate_index", + "name": "annotate_index" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 48, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "harmonic_math:active_nodes:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "harmonic_math", + "name": "active_nodes" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 54, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "harmonic_math:graph_harmonics:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "harmonic_math", + "name": "graph_harmonics" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 54, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/module/ratios%2Fharmonics.py", + "identity": "ratios/harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_bfs_distances/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_bfs_distances", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:_bfs_distances", + "decorators": [], + "kind": "function", + "name": "_bfs_distances", + "parent_identity": null, + "qualified_name": "_bfs_distances", + "signature": "def _bfs_distances(graph: dict[str, set[str]], anchor: str) -> dict[str, int]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 204, + "span": { + "end": { + "byte": 7716, + "column": 20, + "line": 204 + }, + "start": { + "byte": 7227, + "column": 0, + "line": 193 + } + }, + "start_line": 193 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_bfs_distances", + "identity": "_bfs_distances", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_load_semantic_collection/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:_load_semantic_collection", + "metadata_kind": "comment", + "text": "type: ignore" + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 212, + "span": { + "end": { + "byte": 7960, + "column": 57, + "line": 212 + }, + "start": { + "byte": 7946, + "column": 43, + "line": 212 + } + }, + "start_line": 212 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_load_semantic_collection", + "identity": "_load_semantic_collection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_load_semantic_collection/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_load_semantic_collection", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:_load_semantic_collection", + "decorators": [], + "kind": "function", + "name": "_load_semantic_collection", + "parent_identity": null, + "qualified_name": "_load_semantic_collection", + "signature": "def _load_semantic_collection(root: Path, repo: str) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 215, + "span": { + "end": { + "byte": 8109, + "column": 30, + "line": 215 + }, + "start": { + "byte": 7719, + "column": 0, + "line": 207 + } + }, + "start_line": 207 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_load_semantic_collection", + "identity": "_load_semantic_collection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_load_semantic_collection/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collect:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collect" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 212, + "start_line": 212 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_load_semantic_collection", + "identity": "_load_semantic_collection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_prepare_graph/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_prepare_graph", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:_prepare_graph", + "decorators": [], + "kind": "function", + "name": "_prepare_graph", + "parent_identity": null, + "qualified_name": "_prepare_graph", + "signature": "def _prepare_graph(root: Path, domain: str, signal_name: str, repo: str) -> tuple[dict, dict, dict]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 237, + "span": { + "end": { + "byte": 9204, + "column": 41, + "line": 237 + }, + "start": { + "byte": 8112, + "column": 0, + "line": 218 + } + }, + "start_line": 218 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_prepare_graph", + "identity": "_prepare_graph", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_print_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_print_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:_print_text", + "decorators": [], + "kind": "function", + "name": "_print_text", + "parent_identity": null, + "qualified_name": "_print_text", + "signature": "def _print_text(report: dict, top: int) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 310, + "span": { + "end": { + "byte": 12985, + "column": 32, + "line": 310 + }, + "start": { + "byte": 12319, + "column": 0, + "line": 298 + } + }, + "start_line": 298 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_print_text", + "identity": "_print_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_relative/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_relative", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:_relative", + "decorators": [], + "kind": "function", + "name": "_relative", + "parent_identity": null, + "qualified_name": "_relative", + "signature": "def _relative(path: str, root: Path) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 244, + "span": { + "end": { + "byte": 9362, + "column": 19, + "line": 244 + }, + "start": { + "byte": 9207, + "column": 0, + "line": 240 + } + }, + "start_line": 240 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_relative", + "identity": "_relative", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_source_without_ratio_lines/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_source_without_ratio_lines", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:_source_without_ratio_lines", + "decorators": [], + "kind": "function", + "name": "_source_without_ratio_lines", + "parent_identity": null, + "qualified_name": "_source_without_ratio_lines", + "signature": "def _source_without_ratio_lines(path: Path) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 137, + "span": { + "end": { + "byte": 5183, + "column": 14, + "line": 137 + }, + "start": { + "byte": 4846, + "column": 0, + "line": 130 + } + }, + "start_line": 130 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/_source_without_ratio_lines", + "identity": "_source_without_ratio_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/analyze/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "analyze", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:analyze", + "decorators": [], + "kind": "function", + "name": "analyze", + "parent_identity": null, + "qualified_name": "analyze", + "signature": "def analyze(args: argparse.Namespace) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 295, + "span": { + "end": { + "byte": 12316, + "column": 5, + "line": 295 + }, + "start": { + "byte": 9365, + "column": 0, + "line": 247 + } + }, + "start_line": 247 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/analyze", + "identity": "analyze", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/bounded_contrast/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "bounded_contrast", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:bounded_contrast", + "decorators": [], + "kind": "function", + "name": "bounded_contrast", + "parent_identity": null, + "qualified_name": "bounded_contrast", + "signature": "def bounded_contrast(a: float, b: float) -> float | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 63, + "span": { + "end": { + "byte": 2372, + "column": 52, + "line": 63 + }, + "start": { + "byte": 2193, + "column": 0, + "line": 61 + } + }, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/bounded_contrast", + "identity": "bounded_contrast", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/bounded_contrast/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:bounded_contrast", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return (a-b)/(a+b), preserving the 0:0 state as undefined.", + "text": "Return (a-b)/(a+b), preserving the 0:0 state as undefined." + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 62, + "span": { + "end": { + "byte": 2319, + "column": 68, + "line": 62 + }, + "start": { + "byte": 2255, + "column": 4, + "line": 62 + } + }, + "start_line": 62 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/bounded_contrast", + "identity": "bounded_contrast", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/build_parser/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "build_parser", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:build_parser", + "decorators": [], + "kind": "function", + "name": "build_parser", + "parent_identity": null, + "qualified_name": "build_parser", + "signature": "def build_parser() -> argparse.ArgumentParser" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 328, + "span": { + "end": { + "byte": 14414, + "column": 17, + "line": 328 + }, + "start": { + "byte": 12988, + "column": 0, + "line": 313 + } + }, + "start_line": 313 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/build_parser", + "identity": "build_parser", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: list[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 349, + "span": { + "end": { + "byte": 15178, + "column": 12, + "line": 349 + }, + "start": { + "byte": 14417, + "column": 0, + "line": 331 + } + }, + "start_line": 331 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/metric_signal/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "metric_signal", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:metric_signal", + "decorators": [], + "kind": "function", + "name": "metric_signal", + "parent_identity": null, + "qualified_name": "metric_signal", + "signature": "def metric_signal(index: dict[str, dict], signal: str) -> tuple[dict[str, float], list[str]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 89, + "span": { + "end": { + "byte": 3218, + "column": 23, + "line": 89 + }, + "start": { + "byte": 2853, + "column": 0, + "line": 80 + } + }, + "start_line": 80 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/metric_signal", + "identity": "metric_signal", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/metric_value/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "metric_value", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:metric_value", + "decorators": [], + "kind": "function", + "name": "metric_value", + "parent_identity": null, + "qualified_name": "metric_value", + "signature": "def metric_value(metrics: dict, signal: str) -> float | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 77, + "span": { + "end": { + "byte": 2850, + "column": 72, + "line": 77 + }, + "start": { + "byte": 2375, + "column": 0, + "line": 66 + } + }, + "start_line": 66 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/metric_value", + "identity": "metric_value", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/semantic_file_graph/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "semantic_file_graph", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:semantic_file_graph", + "decorators": [], + "kind": "function", + "name": "semantic_file_graph", + "parent_identity": null, + "qualified_name": "semantic_file_graph", + "signature": "def semantic_file_graph(collection: dict, root: Path, eligible: Iterable[str]) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 127, + "span": { + "end": { + "byte": 4843, + "column": 5, + "line": 127 + }, + "start": { + "byte": 3221, + "column": 0, + "line": 92 + } + }, + "start_line": 92 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/semantic_file_graph", + "identity": "semantic_file_graph", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/semantic_file_graph/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:semantic_file_graph", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Project msdmd declaration edges onto source files that own both ids.", + "text": "Project msdmd declaration edges onto source files that own both ids." + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 93, + "span": { + "end": { + "byte": 3387, + "column": 78, + "line": 93 + }, + "start": { + "byte": 3313, + "column": 4, + "line": 93 + } + }, + "start_line": 93 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/semantic_file_graph", + "identity": "semantic_file_graph", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/source_balance_series/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "source_balance_series", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:source_balance_series", + "decorators": [], + "kind": "function", + "name": "source_balance_series", + "parent_identity": null, + "qualified_name": "source_balance_series", + "signature": "def source_balance_series(path: Path) -> tuple[list[float], list[float], dict]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 190, + "span": { + "end": { + "byte": 7224, + "column": 5, + "line": 190 + }, + "start": { + "byte": 5186, + "column": 0, + "line": 140 + } + }, + "start_line": 140 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/source_balance_series", + "identity": "source_balance_series", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/source_balance_series/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/harmonics.py::function:source_balance_series", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return line-position and +code/-comment balance matching canonical N:M semantics.", + "text": "Return line-position and +code/-comment balance matching canonical N:M semantics." + } + }, + "origin": "native", + "source": { + "content_sha256": "3beed5c35fd99a7a9bd6b4e7a5f6e0589de8c3709b57c19133a4af98c4f5bd78", + "file": "ratios/harmonics.py", + "location": { + "end_line": 141, + "span": { + "end": { + "byte": 5357, + "column": 91, + "line": 141 + }, + "start": { + "byte": 5270, + "column": 4, + "line": 141 + } + }, + "start_line": 141 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/harmonics.py#subject/symbol/source_balance_series", + "identity": "source_balance_series", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "86:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A292-292/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "86:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 292, + "start_line": 292 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "6:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A292-292/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "6:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 292, + "start_line": 292 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "218:33" + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A292-292/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "218:33" + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 292, + "start_line": 292 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=218:33 imports_exports=6:7 calls_definitions=86:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 73, + "column": 73, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::<module>", + "metadata_kind": "comment", + "text": "Make the sibling ``msdmd`` skill importable whether run from a repo root or\nfrom a vendored ``.agents/skills/ratios/`` directory." + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 33, + "span": { + "end": { + "byte": 1519, + "column": 55, + "line": 33 + }, + "start": { + "byte": 1386, + "column": 0, + "line": 32 + } + }, + "start_line": 32 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::<module>", + "metadata_kind": "comment", + "text": "noqa: E402" + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 35, + "span": { + "end": { + "byte": 1635, + "column": 51, + "line": 35 + }, + "start": { + "byte": 1623, + "column": 39, + "line": 35 + } + }, + "start_line": 35 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::<module>", + "metadata_kind": "comment", + "text": "Legacy fenced block (tolerated so transitional files don't pollute the\ncounts) plus the canonical single-line form, both self-excluded." + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 49, + "span": { + "end": { + "byte": 2024, + "column": 66, + "line": 49 + }, + "start": { + "byte": 1885, + "column": 0, + "line": 48 + } + }, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::<module>", + "metadata_kind": "comment", + "text": "The named-form computers above use Python imports, definitions, docstrings,\nand call syntax. Other parser-supported languages remain discoverable without\nbecoming false strict-mode gaps or receiving Python-shaped verification." + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 156, + "span": { + "end": { + "byte": 5692, + "column": 74, + "line": 156 + }, + "start": { + "byte": 5460, + "column": 0, + "line": 154 + } + }, + "start_line": 154 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/comment/5", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=218:33 imports_exports=6:7 calls_definitions=86:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 292, + "span": { + "end": { + "byte": 10663, + "column": 73, + "line": 292 + }, + "start": { + "byte": 10590, + "column": 0, + "line": 292 + } + }, + "start_line": 292 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::<module>", + "description": "Reference runner for the ``ratios`` skill. It reads the single-line RATIOS\ndeclaration (``<marker> ratios: loc_comments=N:M imports_exports=N:M\ncalls_definitions=N:M``) from a file's opening and closing source boundaries,\nrecomputes each ratio from the source, and fails on:\n\n * drift — a recorded ratio no longer matches what the source computes;\n * misplaced — a RATIOS declaration not on both source boundaries;\n * gaps — (only under ``--strict``) computer-supported files with no\n RATIOS at all.\n\n``value: hmmm`` is reported as pending, never a failure. A recorded id with no\nregistered computer is reported as unverifiable (informational). Pure stdlib;\nthe single-line reader is reused from the msdmd universal parser, not forked.\nThe bundled computers are Python-specific. Parser support for another language\ndoes not silently opt that language into Python metric semantics.\n\nUsage:\n python ratios_check.py path/to/module.py # verify one file\n python ratios_check.py --root . # walk a tree\n python ratios_check.py --root . --strict # gaps also fail (CI gate)", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "ratios skill executor — recompute the canonical ratios and gate on drift.", + "text": "ratios skill executor — recompute the canonical ratios and gate on drift.\n\nReference runner for the ``ratios`` skill. It reads the single-line RATIOS\ndeclaration (``<marker> ratios: loc_comments=N:M imports_exports=N:M\ncalls_definitions=N:M``) from a file's opening and closing source boundaries,\nrecomputes each ratio from the source, and fails on:\n\n * drift — a recorded ratio no longer matches what the source computes;\n * misplaced — a RATIOS declaration not on both source boundaries;\n * gaps — (only under ``--strict``) computer-supported files with no\n RATIOS at all.\n\n``value: hmmm`` is reported as pending, never a failure. A recorded id with no\nregistered computer is reported as unverifiable (informational). Pure stdlib;\nthe single-line reader is reused from the msdmd universal parser, not forked.\nThe bundled computers are Python-specific. Parser support for another language\ndoes not silently opt that language into Python metric semantics.\n\nUsage:\n python ratios_check.py path/to/module.py # verify one file\n python ratios_check.py --root . # walk a tree\n python ratios_check.py --root . --strict # gaps also fail (CI gate)\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 24, + "span": { + "end": { + "byte": 1292, + "column": 3, + "line": 24 + }, + "start": { + "byte": 74, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 25, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 27, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 28, + "start_line": 28 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 29, + "start_line": 29 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 30, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:RATIO_IDS:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "RATIO_IDS" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 40, + "start_line": 35 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:marker_for:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "marker_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 40, + "start_line": 35 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:parse_ratios:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "parse_ratios" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 40, + "start_line": 35 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:ratios_placement:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "ratios_placement" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 40, + "start_line": 35 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/module/ratios%2Fratios_check.py", + "identity": "ratios/ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_classify_lines/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_classify_lines", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:_classify_lines", + "decorators": [], + "kind": "function", + "name": "_classify_lines", + "parent_identity": null, + "qualified_name": "_classify_lines", + "signature": "def _classify_lines(text: str) -> dict[str, list[int]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 101, + "span": { + "end": { + "byte": 3818, + "column": 14, + "line": 101 + }, + "start": { + "byte": 2743, + "column": 0, + "line": 70 + } + }, + "start_line": 70 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_classify_lines", + "identity": "_classify_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_classify_lines/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:_classify_lines", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Partition line indices into code / comment / docstring / blank.", + "text": "Partition line indices into code / comment / docstring / blank." + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 71, + "span": { + "end": { + "byte": 2872, + "column": 73, + "line": 71 + }, + "start": { + "byte": 2803, + "column": 4, + "line": 71 + } + }, + "start_line": 71 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_classify_lines", + "identity": "_classify_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_iter_source/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_iter_source", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:_iter_source", + "decorators": [], + "kind": "function", + "name": "_iter_source", + "parent_identity": null, + "qualified_name": "_iter_source", + "signature": "def _iter_source(root: Path)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 167, + "span": { + "end": { + "byte": 6087, + "column": 23, + "line": 167 + }, + "start": { + "byte": 5725, + "column": 0, + "line": 160 + } + }, + "start_line": 160 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_iter_source", + "identity": "_iter_source", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_iter_source/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:_iter_source", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Yield every source file under ``root`` with a known comment marker.", + "text": "Yield every source file under ``root`` with a known comment marker." + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 161, + "span": { + "end": { + "byte": 5832, + "column": 77, + "line": 161 + }, + "start": { + "byte": 5759, + "column": 4, + "line": 161 + } + }, + "start_line": 161 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_iter_source", + "identity": "_iter_source", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_strip_ratios_lines/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_strip_ratios_lines", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:_strip_ratios_lines", + "decorators": [], + "kind": "function", + "name": "_strip_ratios_lines", + "parent_identity": null, + "qualified_name": "_strip_ratios_lines", + "signature": "def _strip_ratios_lines(text: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 67, + "span": { + "end": { + "byte": 2740, + "column": 15, + "line": 67 + }, + "start": { + "byte": 2527, + "column": 0, + "line": 63 + } + }, + "start_line": 63 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_strip_ratios_lines", + "identity": "_strip_ratios_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_strip_ratios_lines/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:_strip_ratios_lines", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Remove every RATIOS declaration so ratios self-exclude from counts.", + "text": "Remove every RATIOS declaration so ratios self-exclude from counts." + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 64, + "span": { + "end": { + "byte": 2647, + "column": 77, + "line": 64 + }, + "start": { + "byte": 2574, + "column": 4, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_strip_ratios_lines", + "identity": "_strip_ratios_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_verify_file/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:_verify_file", + "metadata_kind": "comment", + "text": "pragma: no cover - defensive" + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 221, + "span": { + "end": { + "byte": 7977, + "column": 63, + "line": 221 + }, + "start": { + "byte": 7947, + "column": 33, + "line": 221 + } + }, + "start_line": 221 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_verify_file", + "identity": "_verify_file", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_verify_file/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_verify_file", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:_verify_file", + "decorators": [], + "kind": "function", + "name": "_verify_file", + "parent_identity": null, + "qualified_name": "_verify_file", + "signature": "def _verify_file(path: Path, base: Path, rep: dict) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 227, + "span": { + "end": { + "byte": 8321, + "column": 76, + "line": 227 + }, + "start": { + "byte": 6090, + "column": 0, + "line": 170 + } + }, + "start_line": 170 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/_verify_file", + "identity": "_verify_file", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_calls_definitions/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "compute_calls_definitions", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:compute_calls_definitions", + "decorators": [], + "kind": "function", + "name": "compute_calls_definitions", + "parent_identity": null, + "qualified_name": "compute_calls_definitions", + "signature": "def compute_calls_definitions(text: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 145, + "span": { + "end": { + "byte": 5298, + "column": 38, + "line": 145 + }, + "start": { + "byte": 4660, + "column": 0, + "line": 129 + } + }, + "start_line": 129 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_calls_definitions", + "identity": "compute_calls_definitions", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_calls_definitions/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:compute_calls_definitions", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "call-site lines : definition lines (top-level + one nesting level).", + "text": "call-site lines : definition lines (top-level + one nesting level)." + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 130, + "span": { + "end": { + "byte": 4786, + "column": 77, + "line": 130 + }, + "start": { + "byte": 4713, + "column": 4, + "line": 130 + } + }, + "start_line": 130 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_calls_definitions", + "identity": "compute_calls_definitions", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_imports_exports/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "compute_imports_exports", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:compute_imports_exports", + "decorators": [], + "kind": "function", + "name": "compute_imports_exports", + "parent_identity": null, + "qualified_name": "compute_imports_exports", + "signature": "def compute_imports_exports(text: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 126, + "span": { + "end": { + "byte": 4657, + "column": 43, + "line": 126 + }, + "start": { + "byte": 4086, + "column": 0, + "line": 112 + } + }, + "start_line": 112 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_imports_exports", + "identity": "compute_imports_exports", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_imports_exports/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:compute_imports_exports", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "import_count : public-export count (+1 if __all__ present).", + "text": "import_count : public-export count (+1 if __all__ present)." + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 113, + "span": { + "end": { + "byte": 4202, + "column": 69, + "line": 113 + }, + "start": { + "byte": 4137, + "column": 4, + "line": 113 + } + }, + "start_line": 113 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_imports_exports", + "identity": "compute_imports_exports", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_loc_comments/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "compute_loc_comments", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:compute_loc_comments", + "decorators": [], + "kind": "function", + "name": "compute_loc_comments", + "parent_identity": null, + "qualified_name": "compute_loc_comments", + "signature": "def compute_loc_comments(text: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 109, + "span": { + "end": { + "byte": 4083, + "column": 21, + "line": 109 + }, + "start": { + "byte": 3821, + "column": 0, + "line": 104 + } + }, + "start_line": 104 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_loc_comments", + "identity": "compute_loc_comments", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_loc_comments/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:compute_loc_comments", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "N:M where N = code lines, M = comment + docstring lines.", + "text": "N:M where N = code lines, M = comment + docstring lines." + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 105, + "span": { + "end": { + "byte": 3931, + "column": 66, + "line": 105 + }, + "start": { + "byte": 3869, + "column": 4, + "line": 105 + } + }, + "start_line": 105 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/compute_loc_comments", + "identity": "compute_loc_comments", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: list[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 287, + "span": { + "end": { + "byte": 10531, + "column": 27, + "line": 287 + }, + "start": { + "byte": 9682, + "column": 0, + "line": 265 + } + }, + "start_line": 265 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/run/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "run", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:run", + "decorators": [], + "kind": "function", + "name": "run", + "parent_identity": null, + "qualified_name": "run", + "signature": "def run(target: Path) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 251, + "span": { + "end": { + "byte": 9234, + "column": 14, + "line": 251 + }, + "start": { + "byte": 8324, + "column": 0, + "line": 230 + } + }, + "start_line": 230 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/run", + "identity": "run", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/run/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:run", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Verify one file or every source file under a directory.", + "text": "Verify one file or every source file under a directory." + } + }, + "origin": "native", + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 231, + "span": { + "end": { + "byte": 8420, + "column": 65, + "line": 231 + }, + "start": { + "byte": 8359, + "column": 4, + "line": 231 + } + }, + "start_line": 231 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/run", + "identity": "run", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/summary/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "summary", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:ratios/ratios_check.py::function:summary", + "decorators": [], + "kind": "function", + "name": "summary", + "parent_identity": null, + "qualified_name": "summary", + "signature": "def summary(rep: dict) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "efd14c88b0cef1495f1db3ebaf7a54d96926208156b99d96a9bd6f92cc3db6c7", + "file": "ratios/ratios_check.py", + "location": { + "end_line": 262, + "span": { + "end": { + "byte": 9679, + "column": 5, + "line": 262 + }, + "start": { + "byte": 9237, + "column": 0, + "line": 254 + } + }, + "start_line": 254 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ratios/ratios_check.py#subject/symbol/summary", + "identity": "summary", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/repo-audit-repair/SKILL.md#subject/document/repo-audit-repair%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Evidence-led repository audit and repair from exact repository identity through authoritative verification. Use this when asked to audit, assess, harden, clean up, or audit and repair an existing code repository; when a green build may conceal placeholder gates, deprecated paths, or partial publication; or when repair must distinguish repository defects from environment, external-service, policy, and unresolved conditions. Do not load for an ordinary fixed-scope edit, a narrow review, or diagnosis of one already-localized failure unless the user requests a broader repository audit.", + "name": "repo-audit-repair" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "c45a813782c5443f05224a4600572694808b69d25b6bff9951e5c3023a123a0c", + "file": "repo-audit-repair/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/repo-audit-repair/SKILL.md#subject/document/repo-audit-repair%2FSKILL.md", + "identity": "repo-audit-repair/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/risk-boundary-build/SKILL.md#subject/document/risk-boundary-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first runtime risk and permission boundaries built on msdmd. Consume existing permission, schema, configuration and effect declarations; supplemental BOUNDARIES blocks express otherwise missing auth, storage, network, user-data and operational effects. Declarations do not prove enforcement. Load this when touching permissions, persistence, network calls, user data, admin behavior, migrations, or other risk-bearing effects.", + "name": "risk-boundary-build" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "3b27c19a2b671d5a9edfed24912fcbbdcb9d88cf4b5a7e6b31e732b4f3dcf907", + "file": "risk-boundary-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/risk-boundary-build/SKILL.md#subject/document/risk-boundary-build%2FSKILL.md", + "identity": "risk-boundary-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill-build/SKILL.md#subject/document/skill-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Skill authoring and skill compliance workflow for The Interdependency skill-lib. Load this when creating a new SKILL.md, revising an existing skill, bringing repo skills into a shared compliance shape, designing a skill-specific test suite, deciding whether a skill is metadata-block or procedural, or asking the question set required before a skill can be accepted.", + "name": "skill-build" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "faaf097cd8b1da2bf18628a1fa9acebe4a671a20ad5d12301b20422da333a011", + "file": "skill-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill-build/SKILL.md#subject/document/skill-build%2FSKILL.md", + "identity": "skill-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill-usage/SKILL.md#subject/document/skill-usage%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Record and report evidence-bearing usage maturity for skills installed from The Interdependency skill-lib. Load this when any other skill-lib skill is invoked, and when asked for skill counts, usage history, maturity, reliability, experimental status, field-test status, operational status, or daily-use status.", + "name": "skill-usage" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "a225992847b15c53803d01c25860f0ad4bc1e9cfd868d5b48750c6fc58bf0bb4", + "file": "skill-usage/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill-usage/SKILL.md#subject/document/skill-usage%2FSKILL.md", + "identity": "skill-usage/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "161:29" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A456-456/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "161:29" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 456, + "start_line": 456 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "9:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A456-456/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "9:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 456, + "start_line": 456 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "300:82" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A456-456/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "300:82" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 456, + "start_line": 456 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=300:82 imports_exports=9:10 calls_definitions=161:29" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 75, + "column": 75, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: repo_mutation_gate\n module_name: repo_loto\n module_kind: instrument\n summary: delete-on-completion session gate for repo mutation; presence of state means open work, absence means clean\n owner: Way Seer Erin\n public_surface: loto open, loto run, loto test, loto close, loto fail, loto clear, loto status, loto guard, loto install-hook\n internal_surface: _load, _save, _touched_files, _scope_violations, _trailers, _digest, _commit, _git, _ensure_gitignored\n auth_boundary: none\n storage_boundary: write\n network_boundary: none\n user_data_boundary: none\n admin_only: false\n tests: tests/test_repo_loto.py (CHECKS-declared, reconciled via --audit)\n rollout: manual invocation; pre-push hook calls `loto guard`\n rollback: rm -rf .loto/ and remove hook line\n unresolved: credential-gate integration, ratios bookends\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 19, + "span": { + "end": { + "byte": 988, + "column": 26, + "line": 19 + }, + "start": { + "byte": 76, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CONTRACTS ===\nid: loto_open_never_dirties\n given: clean working tree; `loto open` succeeds\n then: working tree is still clean; exclusion went to .git/info/exclude, never .gitignore\n class: doctrine\n\nid: loto_close_deletes_tag\n given: one in-scope mutation commit and passing test evidence; `loto close`\n then: .loto/ is empty and HEAD carries Loto-* trailers; git is the only archive\n class: doctrine\n\nid: loto_latest_test_wins\n given: a failing run of a test command followed by a passing run of the identical command\n then: close proceeds; a distinct command whose latest run failed still blocks close\n class: evidence\n\nid: loto_scope_enforced\n given: files touched outside the declared --files globs\n then: close refuses with the violating paths named\n class: safety\n\nid: loto_scar_blocks_work\n given: an unacknowledged SCAR-*.json in .loto/\n then: `loto open` refuses and `loto guard` exits nonzero\n class: safety\n\nid: loto_clear_is_empty_commit\n given: `loto clear` on a scar\n then: refused on dirty tree; on clean tree produces a commit touching zero files, carrying scar trailers, and deletes the scar\n class: doctrine\n\nid: loto_one_commit_per_session\n given: more than one commit between base and HEAD at close\n then: close refuses (v0.1 invariant: one session, one mutation commit)\n class: doctrine\n=== END CONTRACTS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 55, + "span": { + "end": { + "byte": 2409, + "column": 23, + "line": 55 + }, + "start": { + "byte": 989, + "column": 0, + "line": 20 + } + }, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::<module>", + "metadata_kind": "comment", + "text": "---------- git plumbing ----------" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 84, + "span": { + "end": { + "byte": 3223, + "column": 36, + "line": 84 + }, + "start": { + "byte": 3187, + "column": 0, + "line": 84 + } + }, + "start_line": 84 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::<module>", + "metadata_kind": "comment", + "text": "---------- state ----------" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 114, + "span": { + "end": { + "byte": 3825, + "column": 29, + "line": 114 + }, + "start": { + "byte": 3796, + "column": 0, + "line": 114 + } + }, + "start_line": 114 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/comment/5", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::<module>", + "metadata_kind": "comment", + "text": "---------- evidence ----------" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 153, + "span": { + "end": { + "byte": 4890, + "column": 32, + "line": 153 + }, + "start": { + "byte": 4858, + "column": 0, + "line": 153 + } + }, + "start_line": 153 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/comment/6", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::<module>", + "metadata_kind": "comment", + "text": "---------- verbs ----------" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 220, + "span": { + "end": { + "byte": 7292, + "column": 29, + "line": 220 + }, + "start": { + "byte": 7263, + "column": 0, + "line": 220 + } + }, + "start_line": 220 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/comment/7", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::<module>", + "metadata_kind": "comment", + "text": "---------- arg helpers ----------" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 420, + "span": { + "end": { + "byte": 14609, + "column": 35, + "line": 420 + }, + "start": { + "byte": 14574, + "column": 0, + "line": 420 + } + }, + "start_line": 420 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/comment/8", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=300:82 imports_exports=9:10 calls_definitions=161:29" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 456, + "span": { + "end": { + "byte": 15445, + "column": 75, + "line": 456 + }, + "start": { + "byte": 15370, + "column": 0, + "line": 456 + } + }, + "start_line": 456 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::<module>", + "description": "Doctrine:\n The ledger is working memory, not archive. Git is the archive.\n PRESENCE of state in .loto/ means work is open or wounded.\n ABSENCE means clean. Steady state of a healthy repo: .loto/ empty.\n\n open -> .loto/active.json exists (the hung tag)\n close -> evidence distilled into git commit trailers; tag deleted\n fail -> tag becomes .loto/SCAR-<id>.json; blocks new work\n clear -> scar acknowledged via empty commit with trailers; scar deleted\n\nNothing here is ever appended forever. Success leaves only the commit.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "repo_loto — lockout/tagout for repo mutation, delete-on-completion style.", + "text": "\nrepo_loto — lockout/tagout for repo mutation, delete-on-completion style.\n\nDoctrine:\n The ledger is working memory, not archive. Git is the archive.\n PRESENCE of state in .loto/ means work is open or wounded.\n ABSENCE means clean. Steady state of a healthy repo: .loto/ empty.\n\n open -> .loto/active.json exists (the hung tag)\n close -> evidence distilled into git commit trailers; tag deleted\n fail -> tag becomes .loto/SCAR-<id>.json; blocks new work\n clear -> scar acknowledged via empty commit with trailers; scar deleted\n\nNothing here is ever appended forever. Success leaves only the commit.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 70, + "span": { + "end": { + "byte": 3026, + "column": 3, + "line": 70 + }, + "start": { + "byte": 2410, + "column": 0, + "line": 56 + } + }, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "fnmatch:fnmatch:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "fnmatch", + "name": "fnmatch" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 72, + "start_line": 72 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 73, + "start_line": 73 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 74, + "start_line": 74 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 75, + "start_line": 75 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 76, + "start_line": 76 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "time:time:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "time", + "name": "time" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 77, + "start_line": 77 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "uuid:uuid:6", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "uuid", + "name": "uuid" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 78, + "start_line": 78 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/module/skill_lib%2Fsafety%2Frepo_loto.py", + "identity": "skill_lib/safety/repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_branch/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_branch", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_branch", + "decorators": [], + "kind": "function", + "name": "_branch", + "parent_identity": null, + "qualified_name": "_branch", + "signature": "def _branch()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 107, + "span": { + "end": { + "byte": 3730, + "column": 52, + "line": 107 + }, + "start": { + "byte": 3663, + "column": 0, + "line": 106 + } + }, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_branch", + "identity": "_branch", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_commit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_commit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_commit", + "decorators": [], + "kind": "function", + "name": "_commit", + "parent_identity": null, + "qualified_name": "_commit", + "signature": "def _commit(msg, amend=False, allow_empty=False)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 341, + "span": { + "end": { + "byte": 11877, + "column": 23, + "line": 341 + }, + "start": { + "byte": 11344, + "column": 0, + "line": 326 + } + }, + "start_line": 326 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_commit", + "identity": "_commit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_commit/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_commit", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "multiline messages via -F tempfile, inspectable and quote-safe.", + "text": "multiline messages via -F tempfile, inspectable and quote-safe." + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 327, + "span": { + "end": { + "byte": 11467, + "column": 73, + "line": 327 + }, + "start": { + "byte": 11398, + "column": 4, + "line": 327 + } + }, + "start_line": 327 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_commit", + "identity": "_commit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_commit/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 328, + "start_line": 328 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_commit", + "identity": "_commit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_die/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_die", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_die", + "decorators": [], + "kind": "function", + "name": "_die", + "parent_identity": null, + "qualified_name": "_die", + "signature": "def _die(msg, code=1)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 95, + "span": { + "end": { + "byte": 3540, + "column": 18, + "line": 95 + }, + "start": { + "byte": 3456, + "column": 0, + "line": 93 + } + }, + "start_line": 93 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_die", + "identity": "_die", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_digest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_digest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_digest", + "decorators": [], + "kind": "function", + "name": "_digest", + "parent_identity": null, + "qualified_name": "_digest", + "signature": "def _digest(tag)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 188, + "span": { + "end": { + "byte": 6154, + "column": 48, + "line": 188 + }, + "start": { + "byte": 5810, + "column": 0, + "line": 182 + } + }, + "start_line": 182 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_digest", + "identity": "_digest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_digest/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_digest", + "description": "verifiable against scrollback/shell history if ever disputed.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "sha256 shadow of the working memory that close will delete.", + "text": "sha256 shadow of the working memory that close will delete.\n verifiable against scrollback/shell history if ever disputed." + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 184, + "span": { + "end": { + "byte": 5963, + "column": 68, + "line": 184 + }, + "start": { + "byte": 5832, + "column": 4, + "line": 183 + } + }, + "start_line": 183 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_digest", + "identity": "_digest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_digest/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 185, + "start_line": 185 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_digest", + "identity": "_digest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_dirty/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_dirty", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_dirty", + "decorators": [], + "kind": "function", + "name": "_dirty", + "parent_identity": null, + "qualified_name": "_dirty", + "signature": "def _dirty()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 111, + "span": { + "end": { + "byte": 3793, + "column": 46, + "line": 111 + }, + "start": { + "byte": 3733, + "column": 0, + "line": 110 + } + }, + "start_line": 110 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_dirty", + "identity": "_dirty", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_ensure_gitignored/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_ensure_gitignored", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_ensure_gitignored", + "decorators": [], + "kind": "function", + "name": "_ensure_gitignored", + "parent_identity": null, + "qualified_name": "_ensure_gitignored", + "signature": "def _ensure_gitignored()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 129, + "span": { + "end": { + "byte": 4370, + "column": 28, + "line": 129 + }, + "start": { + "byte": 3827, + "column": 0, + "line": 116 + } + }, + "start_line": 116 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_ensure_gitignored", + "identity": "_ensure_gitignored", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_ensure_gitignored/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_ensure_gitignored", + "description": "tag must never dirty the tree, so use .git/info/exclude, not .gitignore.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "working memory must never enter the archive — and hanging the", + "text": "working memory must never enter the archive — and hanging the\n tag must never dirty the tree, so use .git/info/exclude, not .gitignore." + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 118, + "span": { + "end": { + "byte": 4003, + "column": 79, + "line": 118 + }, + "start": { + "byte": 3857, + "column": 4, + "line": 117 + } + }, + "start_line": 117 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_ensure_gitignored", + "identity": "_ensure_gitignored", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_git/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_git", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_git", + "decorators": [], + "kind": "function", + "name": "_git", + "parent_identity": null, + "qualified_name": "_git", + "signature": "def _git(*args, check=True)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 90, + "span": { + "end": { + "byte": 3453, + "column": 27, + "line": 90 + }, + "start": { + "byte": 3225, + "column": 0, + "line": 86 + } + }, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_git", + "identity": "_git", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_head/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_head", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_head", + "decorators": [], + "kind": "function", + "name": "_head", + "parent_identity": null, + "qualified_name": "_head", + "signature": "def _head()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 103, + "span": { + "end": { + "byte": 3660, + "column": 36, + "line": 103 + }, + "start": { + "byte": 3611, + "column": 0, + "line": 102 + } + }, + "start_line": 102 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_head", + "identity": "_head", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_latest_tests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_latest_tests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_latest_tests", + "decorators": [], + "kind": "function", + "name": "_latest_tests", + "parent_identity": null, + "qualified_name": "_latest_tests", + "signature": "def _latest_tests(tag)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 179, + "span": { + "end": { + "byte": 5807, + "column": 32, + "line": 179 + }, + "start": { + "byte": 5474, + "column": 0, + "line": 172 + } + }, + "start_line": 172 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_latest_tests", + "identity": "_latest_tests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_latest_tests/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_latest_tests", + "description": "the full record stays in working memory (and in the digest);\nonly the standing evidence is the last run of each command.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "latest-run-wins, per command: a rerun supersedes its predecessor.", + "text": "latest-run-wins, per command: a rerun supersedes its predecessor.\n the full record stays in working memory (and in the digest);\n only the standing evidence is the last run of each command." + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 175, + "span": { + "end": { + "byte": 5702, + "column": 66, + "line": 175 + }, + "start": { + "byte": 5502, + "column": 4, + "line": 173 + } + }, + "start_line": 173 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_latest_tests", + "identity": "_latest_tests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_load/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_load", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_load", + "decorators": [], + "kind": "function", + "name": "_load", + "parent_identity": null, + "qualified_name": "_load", + "signature": "def _load()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 142, + "span": { + "end": { + "byte": 4676, + "column": 27, + "line": 142 + }, + "start": { + "byte": 4519, + "column": 0, + "line": 138 + } + }, + "start_line": 138 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_load", + "identity": "_load", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_opt/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_opt", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_opt", + "decorators": [], + "kind": "function", + "name": "_opt", + "parent_identity": null, + "qualified_name": "_opt", + "signature": "def _opt(args, flag, default)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 434, + "span": { + "end": { + "byte": 14894, + "column": 18, + "line": 434 + }, + "start": { + "byte": 14734, + "column": 0, + "line": 429 + } + }, + "start_line": 429 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_opt", + "identity": "_opt", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_record/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_record", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_record", + "decorators": [], + "kind": "function", + "name": "_record", + "parent_identity": null, + "qualified_name": "_record", + "signature": "def _record(tag_list_key, args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 269, + "span": { + "end": { + "byte": 8986, + "column": 23, + "line": 269 + }, + "start": { + "byte": 8619, + "column": 0, + "line": 256 + } + }, + "start_line": 256 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_record", + "identity": "_record", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_repo_root/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_repo_root", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_repo_root", + "decorators": [], + "kind": "function", + "name": "_repo_root", + "parent_identity": null, + "qualified_name": "_repo_root", + "signature": "def _repo_root()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 99, + "span": { + "end": { + "byte": 3608, + "column": 47, + "line": 99 + }, + "start": { + "byte": 3543, + "column": 0, + "line": 98 + } + }, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_repo_root", + "identity": "_repo_root", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_req/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_req", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_req", + "decorators": [], + "kind": "function", + "name": "_req", + "parent_identity": null, + "qualified_name": "_req", + "signature": "def _req(args, flag)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 426, + "span": { + "end": { + "byte": 14731, + "column": 12, + "line": 426 + }, + "start": { + "byte": 14611, + "column": 0, + "line": 422 + } + }, + "start_line": 422 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_req", + "identity": "_req", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_save/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_save", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_save", + "decorators": [], + "kind": "function", + "name": "_save", + "parent_identity": null, + "qualified_name": "_save", + "signature": "def _save(tag)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 150, + "span": { + "end": { + "byte": 4855, + "column": 27, + "line": 150 + }, + "start": { + "byte": 4679, + "column": 0, + "line": 145 + } + }, + "start_line": 145 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_save", + "identity": "_save", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_scars/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_scars", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_scars", + "decorators": [], + "kind": "function", + "name": "_scars", + "parent_identity": null, + "qualified_name": "_scars", + "signature": "def _scars()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 4516, + "column": 75, + "line": 135 + }, + "start": { + "byte": 4373, + "column": 0, + "line": 132 + } + }, + "start_line": 132 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_scars", + "identity": "_scars", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_scope_violations/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_scope_violations", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_scope_violations", + "decorators": [], + "kind": "function", + "name": "_scope_violations", + "parent_identity": null, + "qualified_name": "_scope_violations", + "signature": "def _scope_violations(tag, touched)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 169, + "span": { + "end": { + "byte": 5471, + "column": 67, + "line": 169 + }, + "start": { + "byte": 5263, + "column": 0, + "line": 164 + } + }, + "start_line": 164 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_scope_violations", + "identity": "_scope_violations", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_touched_files/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_touched_files", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_touched_files", + "decorators": [], + "kind": "function", + "name": "_touched_files", + "parent_identity": null, + "qualified_name": "_touched_files", + "signature": "def _touched_files(tag)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 161, + "span": { + "end": { + "byte": 5260, + "column": 71, + "line": 161 + }, + "start": { + "byte": 4892, + "column": 0, + "line": 155 + } + }, + "start_line": 155 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_touched_files", + "identity": "_touched_files", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_trailers/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_trailers", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:_trailers", + "decorators": [], + "kind": "function", + "name": "_trailers", + "parent_identity": null, + "qualified_name": "_trailers", + "signature": "def _trailers(tag, touched, kind='close')" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 217, + "span": { + "end": { + "byte": 7260, + "column": 27, + "line": 217 + }, + "start": { + "byte": 6157, + "column": 0, + "line": 191 + } + }, + "start_line": 191 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/_trailers", + "identity": "_trailers", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_clear/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "cmd_clear", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_clear", + "decorators": [], + "kind": "function", + "name": "cmd_clear", + "parent_identity": null, + "qualified_name": "cmd_clear", + "signature": "def cmd_clear(args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 374, + "span": { + "end": { + "byte": 13084, + "column": 77, + "line": 374 + }, + "start": { + "byte": 12282, + "column": 0, + "line": 356 + } + }, + "start_line": 356 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_clear", + "identity": "cmd_clear", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_close/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_close", + "metadata_kind": "comment", + "text": "nothing happened; the tag comes off, nothing to archive" + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 294, + "span": { + "end": { + "byte": 9735, + "column": 65, + "line": 294 + }, + "start": { + "byte": 9678, + "column": 8, + "line": 294 + } + }, + "start_line": 294 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_close", + "identity": "cmd_close", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_close/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "cmd_close", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_close", + "decorators": [], + "kind": "function", + "name": "cmd_close", + "parent_identity": null, + "qualified_name": "cmd_close", + "signature": "def cmd_close(args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 323, + "span": { + "end": { + "byte": 11341, + "column": 64, + "line": 323 + }, + "start": { + "byte": 9168, + "column": 0, + "line": 282 + } + }, + "start_line": 282 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_close", + "identity": "cmd_close", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_fail/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "cmd_fail", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_fail", + "decorators": [], + "kind": "function", + "name": "cmd_fail", + "parent_identity": null, + "qualified_name": "cmd_fail", + "signature": "def cmd_fail(args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 353, + "span": { + "end": { + "byte": 12279, + "column": 72, + "line": 353 + }, + "start": { + "byte": 11880, + "column": 0, + "line": 344 + } + }, + "start_line": 344 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_fail", + "identity": "cmd_fail", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_guard/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "cmd_guard", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_guard", + "decorators": [], + "kind": "function", + "name": "cmd_guard", + "parent_identity": null, + "qualified_name": "cmd_guard", + "signature": "def cmd_guard(_args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 399, + "span": { + "end": { + "byte": 13916, + "column": 15, + "line": 399 + }, + "start": { + "byte": 13612, + "column": 0, + "line": 393 + } + }, + "start_line": 393 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_guard", + "identity": "cmd_guard", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_guard/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_guard", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "pre-push hook body: refuse push unless .loto/ is clean.", + "text": "pre-push hook body: refuse push unless .loto/ is clean." + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 394, + "span": { + "end": { + "byte": 13699, + "column": 65, + "line": 394 + }, + "start": { + "byte": 13638, + "column": 4, + "line": 394 + } + }, + "start_line": 394 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_guard", + "identity": "cmd_guard", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_install_hook/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "cmd_install_hook", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_install_hook", + "decorators": [], + "kind": "function", + "name": "cmd_install_hook", + "parent_identity": null, + "qualified_name": "cmd_install_hook", + "signature": "def cmd_install_hook(_args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 417, + "span": { + "end": { + "byte": 14571, + "column": 46, + "line": 417 + }, + "start": { + "byte": 13919, + "column": 0, + "line": 402 + } + }, + "start_line": 402 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_install_hook", + "identity": "cmd_install_hook", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_install_hook/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_install_hook", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "write the pre-push hook so rollout is a command, not a memory.", + "text": "write the pre-push hook so rollout is a command, not a memory." + } + }, + "origin": "native", + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 403, + "span": { + "end": { + "byte": 14020, + "column": 72, + "line": 403 + }, + "start": { + "byte": 13952, + "column": 4, + "line": 403 + } + }, + "start_line": 403 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_install_hook", + "identity": "cmd_install_hook", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_open/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "cmd_open", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_open", + "decorators": [], + "kind": "function", + "name": "cmd_open", + "parent_identity": null, + "qualified_name": "cmd_open", + "signature": "def cmd_open(args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 253, + "span": { + "end": { + "byte": 8616, + "column": 48, + "line": 253 + }, + "start": { + "byte": 7294, + "column": 0, + "line": 222 + } + }, + "start_line": 222 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_open", + "identity": "cmd_open", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_run/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "cmd_run", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_run", + "decorators": [], + "kind": "function", + "name": "cmd_run", + "parent_identity": null, + "qualified_name": "cmd_run", + "signature": "def cmd_run(args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 273, + "span": { + "end": { + "byte": 9047, + "column": 39, + "line": 273 + }, + "start": { + "byte": 8989, + "column": 0, + "line": 272 + } + }, + "start_line": 272 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_run", + "identity": "cmd_run", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_status/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "cmd_status", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_status", + "decorators": [], + "kind": "function", + "name": "cmd_status", + "parent_identity": null, + "qualified_name": "cmd_status", + "signature": "def cmd_status(_args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 390, + "span": { + "end": { + "byte": 13609, + "column": 29, + "line": 390 + }, + "start": { + "byte": 13087, + "column": 0, + "line": 377 + } + }, + "start_line": 377 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_status", + "identity": "cmd_status", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_test/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "cmd_test", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:cmd_test", + "decorators": [], + "kind": "function", + "name": "cmd_test", + "parent_identity": null, + "qualified_name": "cmd_test", + "signature": "def cmd_test(args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 279, + "span": { + "end": { + "byte": 9165, + "column": 18, + "line": 279 + }, + "start": { + "byte": 9050, + "column": 0, + "line": 276 + } + }, + "start_line": 276 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/cmd_test", + "identity": "cmd_test", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:skill_lib/safety/repo_loto.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4407bc4dad15050e705d543ec3e444a9c822d7ef270ce87630d04f2851d83bda", + "file": "skill_lib/safety/repo_loto.py", + "location": { + "end_line": 451, + "span": { + "end": { + "byte": 15329, + "column": 36, + "line": 451 + }, + "start": { + "byte": 15113, + "column": 0, + "line": 445 + } + }, + "start_line": 445 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skill_lib/safety/repo_loto.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills.json#subject/document/skills.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "skill-lib.skills-index", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "install_path": ".agents/skills/<skill-name>/", + "repo": "The-Interdependency/skill-lib", + "skills": [ + { + "description": "Module Self-Declared Metadata in Markdown — native-first collection of metadata already expressed by code, documentation, manifests, schemas, tooling, and evidence formats, with MSDMD blocks only for otherwise unexpressed information. Load this when creating or revising metadata-driven skills, collecting repository metadata, integrating a metadata convention, building parsers or collection consumers, or auditing metadata coverage and provenance.", + "kind": "metadata-block", + "name": "msdmd", + "native_ingestion": { + "manifest": "msdmd/readers.py", + "runner": "msdmd/collect.py", + "schema": "msdmd/collection.ts", + "scope": "fixture-backed native source and structured-standard extraction", + "status": "implemented-subsets" + }, + "path": "msdmd/SKILL.md", + "runner": "msdmd/collect.py", + "runner_scope": "native-and-supplemental", + "status": "runnable" + }, + { + "depends_on": [ + "msdmd" + ], + "description": "Native-first documentation coverage built on msdmd. Consume docstrings, documentation comments and source-linked documents; supplemental DOCS blocks express remaining obligations. A consuming runner verifies references and reports missing information separately from unsupported extraction. Load this when adding or auditing module documentation, tying code surfaces to docs, or wiring documentation coverage checks into CI.", + "kind": "metadata-block", + "name": "doc-build", + "path": "doc-build/SKILL.md" + }, + { + "depends_on": [ + "msdmd" + ], + "description": "Native-first capability inventory built on msdmd. Consume signatures, exports, annotations and API schemas; supplemental CAPABILITIES blocks express otherwise unrecorded behavior and boundaries. Keep declared surfaces separate from verified behavior. Load this when declaring module capabilities, building capability registries for agents, or auditing exposed surfaces against declared capabilities.", + "kind": "metadata-block", + "name": "cap-build", + "path": "cap-build/SKILL.md" + }, + { + "depends_on": [ + "msdmd" + ], + "description": "Native-first dependency topology built on msdmd. Consume imports, package manifests, lockfiles and build declarations at their owning scopes; supplemental DEPENDENCIES blocks express remaining architectural intent. Preserve edge kinds, conditions and resolution uncertainty. Load this when declaring dependencies, auditing architecture drift, checking graph cycles, or wiring dependency topology checks into CI.", + "kind": "metadata-block", + "name": "deps-build", + "path": "deps-build/SKILL.md" + }, + { + "depends_on": [ + "msdmd", + "risk-boundary-build" + ], + "description": "Native-first module stewardship built on msdmd. Consume provider-specific CODEOWNERS, OWNERS and other authoritative responsibility declarations; supplemental OWNERS blocks express missing stewardship or escalation information. Keep review assignment, operational ownership and permissions distinct. Load this when assigning module ownership, routing reviews, auditing unowned code, or wiring stewardship coverage into CI.", + "kind": "metadata-block", + "name": "owner-build", + "path": "owner-build/SKILL.md" + }, + { + "depends_on": [ + "msdmd" + ], + "description": "Native-first contract evidence built on msdmd. Source owners declare behavior obligations and test owners declare accountable witnesses through supported native conventions or supplemental CONTRACTS and CHECKS blocks. Preserve explicit claim linkage and no-exec audit boundaries. Load this when adding tests that use msdmd, refactoring CONTRACTS/CHECKS declarations, or authoring a contract/check audit or executor.", + "kind": "metadata-block", + "name": "test-build", + "path": "test-build/SKILL.md" + }, + { + "depends_on": [ + "msdmd" + ], + "description": "Native-first module planning built on msdmd. Consume existing manifests, schemas and design declarations; supplemental MODULE_BUILD blocks record remaining purpose, surface, boundary, test, rollout and rollback obligations. Load this when turning a capability idea into a bounded module manifest and file plan before implementation.", + "kind": "metadata-block", + "name": "meta-module-build", + "path": "meta-module-build/SKILL.md" + }, + { + "depends_on": [ + "msdmd", + "meta-module-build" + ], + "description": "Native-first runtime risk and permission boundaries built on msdmd. Consume existing permission, schema, configuration and effect declarations; supplemental BOUNDARIES blocks express otherwise missing auth, storage, network, user-data and operational effects. Declarations do not prove enforcement. Load this when touching permissions, persistence, network calls, user data, admin behavior, migrations, or other risk-bearing effects.", + "kind": "metadata-block", + "name": "risk-boundary-build", + "path": "risk-boundary-build/SKILL.md" + }, + { + "depends_on": [ + "msdmd" + ], + "description": "Self-declaring module composition ratios on msdmd — one comment line at a file's opening and closing source boundaries (never a fenced block), with a valid interpreter shebang allowed before the opening seal. The canonical seal is `The-Interdependency/a0`'s compact positional `N:M C:D I:O` annotation (code:comment · consumed:declared · fan-in:fan-out), computed by a0's `scripts/annotate.py`; the named `loc_comments=… imports_exports=… calls_definitions=…` line is a portable, per-file adaptation for standalone libraries, verified by the stdlib `ratios_check.py` (drift/misplacement failures, visible gaps). JSON/Markdown are out of scope. Load this when recording a module's composition ratios, when authoring or extending the ratio registry, or when wiring ratio verification into CI.", + "kind": "metadata-block", + "name": "ratios", + "path": "ratios/SKILL.md" + }, + { + "description": "Canonical-source and doctrine maintenance for The Interdependency skill library. Use this when deciding whether a claim, pattern, ratio, workflow, or repo-local practice should become canon; when moving source-backed behavior into a SKILL.md; when reconciling canonical skill-lib with repo-local `.agents/skills/` copies; or when preserving unresolved doctrine as `hmmm` instead of guessing.", + "kind": "procedural", + "name": "canon", + "path": "canon/SKILL.md" + }, + { + "description": "Domain-first lexical and semantic governance for canonical terms. Load this when a word or phrase is being promoted into a theorem term, ontology primitive, schema field, encoding label, skill doctrine, cross-domain mapping, or other meaning-bearing control surface; when multiple domains use the same word differently; when an acronym, initialism, symbol, or compact handle is being mistaken for a fixed expansion or definition; or when conversational provenance is about to be attached to a definition. Do not load for ordinary prose, casual wording choices, or simple dictionary explanations that will not control canon or structure.", + "kind": "procedural", + "name": "domain-claims", + "path": "domain-claims/SKILL.md" + }, + { + "depends_on": [ + "msdmd" + ], + "description": "Living-spec generator. Derives the mechanical, observable facts of a repo (package name, version, description, license, authors, repository, build backend, development status, supported Python versions, keywords, runtime dependencies, optional extras, top-level layout, CI workflows) from pyproject.toml + the file tree and splices them into a machine-owned, marked block inside CLAUDE.md — keeping the doc from silently drifting from the code. Ships a stdlib-only generator with --write (refresh), --check (CI drift gate), and --print modes. Load this when: setting up or maintaining a CLAUDE.md / AGENTS.md so its factual half is generated rather than hand-typed; wiring a CI check that fails when docs drift from pyproject/version/deps/layout; deciding which parts of a doc to generate vs. hand-author; or onboarding a new org repo to the living-spec convention.", + "kind": "metadata-block", + "name": "manifest", + "path": "manifest/SKILL.md" + }, + { + "depends_on": [ + "msdmd" + ], + "description": "Native-first LLM instruction publication built on msdmd. Consume source-owned instruction metadata without requiring a second copy; the shipped stdlib runner generates llms.txt from LLMS blocks, while native-reader integration remains a contract. Load this when creating, updating, or maintaining llms.txt for repositories consumed by LLMs or agents.", + "kind": "metadata-block", + "name": "llms-build", + "path": "llms-build/SKILL.md" + }, + { + "description": "Character-based context compression for agent handoff and skill writing, owned as a skill-lib procedure rather than current UCNS mathematics. Use this when compressing a long thread, document, repo audit, canon handoff, or agent working-memory state; when a context window is filling and operative facts must survive; when writing a SKILL.md that should be flesh-dense and bone-sparse; or when checking whether a compression deleted negation, order, quantifier, operator, named object, value, decision, or unresolved hmmm. Historical bone/flesh and text-stack terminology is local compression notation, not a UCNS theorem/status transfer, active language-construction authority, or edcmbone metric implementation.", + "kind": "procedural", + "name": "char-compress", + "path": "char-compress/SKILL.md" + }, + { + "description": "Onboarding tour for visitors arriving at any The-Interdependency repo. Load this when an unfamiliar user asks \"what is this?\", \"what is The Interdependency?\", \"how do these repos fit together?\", \"where do I start?\", or otherwise signals they are new to the org. Gives the agent a consistent, repo-aware way to orient a newcomer without inventing facts.", + "kind": "procedural", + "name": "visitor-intro", + "path": "visitor-intro/SKILL.md" + }, + { + "description": "Methodology for instantiating, forking, running, merging, and retiring agents in the a0 platform and its near-identical mirror a0ucns. Load this when adding or changing a sub-agent spawn path, a PCNA instance fork/merge, an agent definition or naming scheme, spawn caps or approval gating, an agent run/log table, a heartbeat-driven agent task, or a checkpoint of agent state. Use it before writing any code that creates, addresses, schedules, or tears down an agent or sub-agent, so the new code follows the platform's existing lifecycle, fork/merge, identity, and gating contracts rather than inventing a parallel one. NOTE — a0-betatest (a0p) has diverged to a different per-user CRUD + native-ZFAE instancing model — this skill's spawn/fork/merge sequence does NOT apply there; see \"a0-betatest divergence\".", + "kind": "procedural", + "name": "agent-instantiation", + "path": "agent-instantiation/SKILL.md" + }, + { + "description": "Methodology for instancing agents in a0-betatest (the a0p research instrument), whose model diverges from canonical a0. Load this when adding or changing an AgentInstance / CharacterSheet CRUD path, a per-instance native ZFAE weight bank or its training/distillation loop, a ZFAE inference mode, a sentinel evaluation or pending-override gate, a per-agent safetensors checkpoint, or volatile sub-context memory — anywhere under a0-betatest `backend/`. Use it before writing code that creates, addresses, trains, runs, governs, or persists an a0p agent, so the code follows a0p's per-user CRUD + native-ZFAE + sentinel model instead of a0's spawn/fork/merge model. For canonical a0 and its mirror a0ucns, use `agent-instantiation` instead — a0p does NOT have `sub_agent_spawn`, a spawn executor, or `InstanceMerge`.", + "kind": "procedural", + "name": "a0p-instancing", + "path": "a0p-instancing/SKILL.md" + }, + { + "description": "Building a plain-language, multi-lens companion view of dense canonical text — an easier on-ramp that does not replace or talk down to the source. Load this when you are asked to make an informationally dense document (canon, spec, articles, legal/normative text) easier to approach for newcomers; when building an \"explain it through the lens of X\" selector (domain, audience, or role); when designing progressive-disclosure or layered ELI-not-stupid reading UX; when a dynamic, data-driven site must keep its existing static page as a graceful fallback; or when you need an EDCM-style two-speaker tension reading between a body text and its footnotes/caveats. Use this when the risk is either drowning readers in density or insulting them with oversimplification.", + "kind": "procedural", + "name": "plain-lens", + "path": "plain-lens/SKILL.md" + }, + { + "description": "Translate raw, context-heavy, recursive, fragmentary, coined, or private-language thought into audience-legible language without changing the underlying claim. Load this when a user says people do not understand what they mean; asks to make a thought understandable to strangers, the public, a specific audience, or a platform; supplies dense notes rather than finished prose; needs jargon or coined terms introduced only after their ordinary-language meaning lands; or wants multiple audience/surface renderings from one thought. Do not load merely to polish finished prose or to simplify an already-stable canonical document; use ordinary editing for the former and plain-lens for the latter.", + "kind": "procedural", + "name": "thought-lens", + "path": "thought-lens/SKILL.md" + }, + { + "description": "METAPAT consultation router for The Interdependency. Load this when deciding which distinctions, relations, boundaries, transformations, scales, or cross-domain correspondences should organize downstream work; when examining available observations or metrics to determine which questions and projections are worth measuring; when the-interdependency skill's METAPAT consultation gate triggers; when an unresolved conceptual choice would constrain architecture, semantics, measurement, ontology, or later claims; or when explicitly asked to consult, apply, or interpret current METAPAT. Do not load merely for routine implementation under already-fixed conceptual contracts.", + "kind": "procedural", + "name": "meta", + "path": "meta/SKILL.md" + }, + { + "description": "Construction, closure, and replay discipline for active gonol-language research. Load this when building or reviewing language constructions made from UCNS gonol objects in The-Interdependency/stack, or when checking closure, atomic participation, provenance, replay, and unresolved geometry boundaries. UCNS owns gonol objects, constructors, and geometry; Stack owns active construction research; EDCM owns measurement/evaluation only. Closed gonols participate atomically at admissible consuming scales; no universal adjacent-scale ladder is required. Pronunciation is not required unless an explicitly declared construction makes it part of the build. Do not load for unrelated geometry, ordinary prose editing, or measurement over already-closed gonols.", + "kind": "procedural", + "name": "gonol-build", + "path": "gonol-build/SKILL.md" + }, + { + "description": "Fail-closed rubric for comparing, retaining, rejecting, deprecating, and selecting UCNS options within an explicit scope. Load this when an agent asks which UCNS candidate should win, whether evidence authorizes selection, how an option moves from registered or implemented to selected, how to compare competing gonol constructors, carriers, geometries, policies, projections, or measurement candidates, or how to issue a scoped UCNS decision receipt. Do not load merely to register options, execute one already-selected option, or choose ordinary UI preferences. Never select universal UCNS canon by score, familiarity, implementation order, or EDCM-local evidence.", + "kind": "procedural", + "name": "ucns-option-selection", + "path": "ucns-option-selection/SKILL.md" + }, + { + "description": "Evidence-bound EPAC target selection and display for WebMCP handoffs and other human-facing surfaces. Load this when choosing an EPAC element, molecule, construction receipt, comparison result, or available visualization to present; when preparing a receipt-backed EPAC display packet; when exposing the EPAC workflow as a selectable WebMCP skill; or when a requested EPAC display would require missing or invented geometry so the request can be refused or downgraded to verified source-backed output. Do not load to select EPAC or a UCNS candidate as canon, or for unrelated WebMCP catalogue changes.", + "kind": "procedural", + "name": "epac-selection-display", + "path": "epac-selection-display/SKILL.md" + }, + { + "description": "Protocol and workflow for all tasks involving The Interdependency organization, its repositories, The Interdependent Way projects, EDCMBONE transcript analysis, code building, research, GitHub maintenance and updates. Load this whenever the task or context touches The-Interdependency assets, or on phrases like \"assemble edcmbone transcripts for analysis\", \"write code that...\", or any GitHub/research/build work on org projects.", + "kind": "procedural", + "name": "the-interdependency", + "path": "the-interdependency/SKILL.md" + }, + { + "description": "Cross-repository coordination for The Interdependency. Load this when a task spans, consumes, compares, publishes to, or can change the contract between two or more repositories; when an agent is about to choose one repo as its workspace for a stack-level problem; when exact producer, evidence-source, skill, semantic, mathematical, or measurement identities must travel together; or when creating a shared stack manifest, multi-repo handoff, coordinated release, or cross-repo validation plan.", + "kind": "procedural", + "name": "interdependent-work-graph", + "path": "interdependent-work-graph/SKILL.md" + }, + { + "description": "Fail-closed update protocol for The-Interdependency/stack. Load this when a stack change adds, moves, extracts, graduates, renames, removes, or changes the authority, relation, source identity, or placement of a participant, research workspace, libs pin, BASE record, stack manifest entry, or architecture description; when stack-manifest.json, STACK_MANIFEST.md, README.md, or research BASE.json files may drift from one another; or when validating that a structural stack change is complete before commit or merge.", + "kind": "procedural", + "name": "stack-update", + "path": "stack-update/SKILL.md" + }, + { + "description": "Project incubation and graduation doctrine for emergent components born inside an integration, stack, laboratory, or incubator repository. Load this when several existing projects compose into a new candidate capability; when assessing whether that candidate should remain incubated or become its own repository/package; when extracting it with provenance; when establishing a new implementation authority boundary; when publishing the extracted project through a registry such as PyPI; or when making the former incubator consume the released artifact instead of its local copy. Do not load for an ordinary new repository with no incubation history or for a routine package release whose authority boundary is already established.", + "kind": "procedural", + "name": "project-incubation-graduation", + "path": "project-incubation-graduation/SKILL.md" + }, + { + "description": "Provenance-bearing publication from distributed source owners. Load this when assembling, displaying, or maintaining one ordered textbook, report, standard, corpus, archive, knowledge surface, or public reading sequence whose authoritative units live in multiple repositories or independently owned files; when a publication consumer must retrieve exact commits, blobs, and content digests; when source order, source-local license or status, explicit fallback, correction routing, or public build identity must remain intact. Load interdependent-work-graph with it. Do not load for ordinary single-repository documentation, a link index that does not reproduce source content, or cross-repository code coordination with no publication artifact.", + "kind": "procedural", + "name": "distributed-publication", + "path": "distributed-publication/SKILL.md" + }, + { + "description": "Load this when any modification to The-Interdependency/The-Interdependency.github.io is planned or underway, including source, content, configuration, tests, workflows, dependencies, generated-contract code, or deployment paths. Every website change transaction must append at least one By the builder entry recording date, time, and the exact runtime model; the model chooses the subject and writes no more than needed to explicate it. Do not load for read-only inspection that changes no website file.", + "kind": "procedural", + "name": "website-builder-journal", + "path": "website-builder-journal/SKILL.md" + }, + { + "description": "Loop engineering for designing closed feedback cycles (Discover→Plan→Execute→Verify→Iterate), single-agent and fleet loops with subagent maker/checker separation, and automated verify-iterate workflows. Load this when building or orchestrating agent systems (a0p, AIMMH), EDCMBONE analysis pipelines, repeatable AI workflows, or any The-Interdependency project that benefits from structured loops instead of manual prompting. Cross-load with the-interdependency for org workflow context.", + "kind": "procedural", + "name": "loop-eng", + "path": "loop-eng/SKILL.md" + }, + { + "description": "Deterministic restoration of derived-artifact consistency after authoritative inputs change. Load this when deciding whether generated or derived outputs are current; when regenerating MSDMD collections, documentation, projections, package indexes, calibration artifacts, or other outputs from exact source identities; when computing the minimum affected rebuild closure; when designing retryable regeneration across unreliable executors; or when a system needs to make artifacts provably fresh rather than merely recently rebuilt. Do not load for ordinary one-shot builds whose inputs and outputs have no persistent freshness contract.", + "kind": "procedural", + "name": "fresh-making", + "path": "fresh-making/SKILL.md" + }, + { + "description": "Action sizing and escalation doctrine. Load this when choosing between the smallest decisive experiment and a maximal coherent program; when asked for the highest-leverage action, minimal versus maximal action, what to do next under time, attention, money, compute, or coordination constraints; when deciding whether to run a bounded falsifier before a full build; or when a task risks scope sprawl. Do not load for a trivial fixed-scope task, immediate emergency containment, or ordinary prioritization that has no evidence or escalation decision.", + "kind": "procedural", + "name": "action-calibration", + "path": "action-calibration/SKILL.md" + }, + { + "description": "Evidence-led repository audit and repair from exact repository identity through authoritative verification. Use this when asked to audit, assess, harden, clean up, or audit and repair an existing code repository; when a green build may conceal placeholder gates, deprecated paths, or partial publication; or when repair must distinguish repository defects from environment, external-service, policy, and unresolved conditions. Do not load for an ordinary fixed-scope edit, a narrow review, or diagnosis of one already-localized failure unless the user requests a broader repository audit.", + "kind": "procedural", + "name": "repo-audit-repair", + "path": "repo-audit-repair/SKILL.md", + "status": "contract" + }, + { + "description": "Skill authoring and skill compliance workflow for The Interdependency skill-lib. Load this when creating a new SKILL.md, revising an existing skill, bringing repo skills into a shared compliance shape, designing a skill-specific test suite, deciding whether a skill is metadata-block or procedural, or asking the question set required before a skill can be accepted.", + "kind": "procedural", + "name": "skill-build", + "path": "skill-build/SKILL.md" + }, + { + "description": "Record and report evidence-bearing usage maturity for skills installed from The Interdependency skill-lib. Load this when any other skill-lib skill is invoked, and when asked for skill counts, usage history, maturity, reliability, experimental status, field-test status, operational status, or daily-use status.", + "kind": "procedural", + "name": "skill-usage", + "path": "skill-usage/SKILL.md" + }, + { + "description": "Fail-closed SSH automation and shell-script delivery for OpenSSH and Google Cloud. Load this when writing, reviewing, or troubleshooting non-interactive SSH scripts, CI/CD remote commands, scp/sftp/rsync-over-SSH workflows, Google Cloud IAP or OS Login automation, remote heredocs, host-key bootstrap, retries and timeouts, or one-box Cloud Shell commands that must not terminate the user's interactive shell. Do not load for one-off interactive login, server-side sshd hardening alone, or MCP-based VM control planes.", + "kind": "procedural", + "name": "ssh-automation", + "path": "ssh-automation/SKILL.md" + }, + { + "description": "Private VM control-plane skill for giving an AI/MCP client SSH-like access to a Linux or Google Compute Engine VM without handing the client an SSH private key. Load this when a user asks to connect ChatGPT, an OpenAI client, Codex, Claude, or another MCP host to a VM; expose bounded shell/file tools on a private VM; replace repeated human SSH with an auditable MCP control plane; install or audit the shipped vm-mcp runtime; or add narrowly scoped administrative actions above the workspace shell. Do not load for ordinary human-only SSH setup with no MCP/agent access.", + "kind": "procedural", + "name": "vm-mcp", + "path": "vm-mcp/SKILL.md" + }, + { + "depends_on": [ + "msdmd", + "meta-module-build", + "doc-build" + ], + "description": "TypeScript frontend generation from backend-owned module metadata and living specs. Load this when building, reviewing, or refactoring a self-building UI that reads backend metadata, exposes every editable field per module, renders each module's living spec, generates TypeScript types/forms/routes from metadata, or keeps admin/editor frontends synchronized with msdmd-style source declarations.", + "kind": "metadata-block", + "name": "typed-meta-frontend", + "path": "typed-meta-frontend/SKILL.md" + }, + { + "description": "Write correct, performant SQL across all major data warehouse dialects (Snowflake, BigQuery, Databricks, PostgreSQL, etc.). Use this when writing queries, optimizing slow SQL, translating between dialects, or building complex analytical queries with CTEs, window functions, or aggregations.", + "kind": "procedural", + "name": "sql-queries", + "path": "sql-queries/SKILL.md", + "provenance": "anthropics/knowledge-work-plugins@94e1a08 (Apache-2.0)" + }, + { + "description": "Apply statistical methods including descriptive stats, trend analysis, outlier detection, and hypothesis testing. Use this when analyzing distributions, testing for significance, detecting anomalies, computing correlations, or interpreting statistical results.", + "kind": "procedural", + "name": "statistical-analysis", + "path": "statistical-analysis/SKILL.md", + "provenance": "anthropics/knowledge-work-plugins@94e1a08 (Apache-2.0)" + }, + { + "description": "Profile and explore a dataset to understand its shape, quality, and patterns. Use this when encountering a new table or file, checking null rates and column distributions, spotting data quality issues like duplicates or suspicious values, or deciding which dimensions and metrics to analyze.", + "kind": "procedural", + "name": "explore-data", + "path": "explore-data/SKILL.md", + "provenance": "anthropics/knowledge-work-plugins@94e1a08 (Apache-2.0)" + }, + { + "description": "QA an analysis before sharing -- methodology, accuracy, and bias checks. Use this when reviewing an analysis before a stakeholder presentation, spot-checking calculations and aggregation logic, verifying a SQL query's results look right, or assessing whether conclusions are actually supported by the data.", + "kind": "procedural", + "name": "validate-data", + "path": "validate-data/SKILL.md", + "provenance": "anthropics/knowledge-work-plugins@94e1a08 (Apache-2.0)" + }, + { + "description": "Create effective data visualizations with Python (matplotlib, seaborn, plotly). Use this when building charts, choosing the right chart type for a dataset, creating publication-quality figures, or applying design principles like accessibility and color theory.", + "kind": "procedural", + "name": "data-visualization", + "path": "data-visualization/SKILL.md", + "provenance": "anthropics/knowledge-work-plugins@94e1a08 (Apache-2.0)" + } + ], + "superseded_skills": [ + { + "name": "gonal-morphology", + "reason": "Deprecated language model; historical evidence remains in Git history but active consumers must remove it.", + "replacements": [ + "gonol-build" + ] + } + ], + "version": 1 + } + }, + "origin": "native", + "source": { + "content_sha256": "9b29cbb4d538080725b90b1c6a2339cea6677f88657ec145e7bfce6edfb72d0e", + "file": "skills.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills.json#subject/document/skills.json", + "identity": "skills.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/a0p-instancing/SKILL.md#subject/document/skills%2Fa0p-instancing%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Methodology for instancing agents in a0-betatest (the a0p research instrument), whose model diverges from canonical a0. Load this when adding or changing an AgentInstance / CharacterSheet CRUD path, a per-instance native ZFAE weight bank or its training/distillation loop, a ZFAE inference mode, a sentinel evaluation or pending-override gate, a per-agent safetensors checkpoint, or volatile sub-context memory — anywhere under a0-betatest `backend/`. Use it before writing code that creates, addresses, trains, runs, governs, or persists an a0p agent, so the code follows a0p's per-user CRUD + native-ZFAE + sentinel model instead of a0's spawn/fork/merge model. For canonical a0 and its mirror a0ucns, use `agent-instantiation` instead — a0p does NOT have `sub_agent_spawn`, a spawn executor, or `InstanceMerge`.", + "name": "a0p-instancing" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "9f42a07170187636ea99851465a48672ad0453689effab922b5c3e14769c807c", + "file": "skills/a0p-instancing/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/a0p-instancing/SKILL.md#subject/document/skills%2Fa0p-instancing%2FSKILL.md", + "identity": "skills/a0p-instancing/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/action-calibration/SKILL.md#subject/document/skills%2Faction-calibration%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Action sizing and escalation doctrine. Load this when choosing between the smallest decisive experiment and a maximal coherent program; when asked for the highest-leverage action, minimal versus maximal action, what to do next under time, attention, money, compute, or coordination constraints; when deciding whether to run a bounded falsifier before a full build; or when a task risks scope sprawl. Do not load for a trivial fixed-scope task, immediate emergency containment, or ordinary prioritization that has no evidence or escalation decision.", + "name": "action-calibration" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "9509aeca38b6c08d5eebf0b7660bcc44a1851ab40c76ef2964d91c02bd10fc29", + "file": "skills/action-calibration/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/action-calibration/SKILL.md#subject/document/skills%2Faction-calibration%2FSKILL.md", + "identity": "skills/action-calibration/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/agent-instantiation/SKILL.md#subject/document/skills%2Fagent-instantiation%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Methodology for instantiating, forking, running, merging, and retiring agents in the a0 platform and its near-identical mirror a0ucns. Load this when adding or changing a sub-agent spawn path, a PCNA instance fork/merge, an agent definition or naming scheme, spawn caps or approval gating, an agent run/log table, a heartbeat-driven agent task, or a checkpoint of agent state. Use it before writing any code that creates, addresses, schedules, or tears down an agent or sub-agent, so the new code follows the platform's existing lifecycle, fork/merge, identity, and gating contracts rather than inventing a parallel one. NOTE — a0-betatest (a0p) has diverged to a different per-user CRUD + native-ZFAE instancing model — this skill's spawn/fork/merge sequence does NOT apply there; see \"a0-betatest divergence\".", + "name": "agent-instantiation" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "0865940e8b893a7f2af826de66a4920c7b4829a09efac8ec2769ea41456fe105", + "file": "skills/agent-instantiation/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/agent-instantiation/SKILL.md#subject/document/skills%2Fagent-instantiation%2FSKILL.md", + "identity": "skills/agent-instantiation/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/canon/SKILL.md#subject/document/skills%2Fcanon%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Canonical-source and doctrine maintenance for The Interdependency skill library. Use this when deciding whether a claim, pattern, ratio, workflow, or repo-local practice should become canon; when moving source-backed behavior into a SKILL.md; when reconciling canonical skill-lib with repo-local `.agents/skills/` copies; or when preserving unresolved doctrine as `hmmm` instead of guessing.", + "name": "canon" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "579cb259ca8c2aae1a93ef41c72cc7037b49f8ba5c226f86d2846397958849ea", + "file": "skills/canon/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/canon/SKILL.md#subject/document/skills%2Fcanon%2FSKILL.md", + "identity": "skills/canon/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/cap-build/SKILL.md#subject/document/skills%2Fcap-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first capability inventory built on msdmd. Consume signatures, exports, annotations and API schemas; supplemental CAPABILITIES blocks express otherwise unrecorded behavior and boundaries. Keep declared surfaces separate from verified behavior. Load this when declaring module capabilities, building capability registries for agents, or auditing exposed surfaces against declared capabilities.", + "name": "cap-build" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "4fd6011f147153e596415a8fc56f76c71d9fc12387e5814a14d58e785c08d7ec", + "file": "skills/cap-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/cap-build/SKILL.md#subject/document/skills%2Fcap-build%2FSKILL.md", + "identity": "skills/cap-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/char-compress/SKILL.md#subject/document/skills%2Fchar-compress%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Character-based context compression for agent handoff and skill writing, owned as a skill-lib procedure rather than current UCNS mathematics. Use this when compressing a long thread, document, repo audit, canon handoff, or agent working-memory state; when a context window is filling and operative facts must survive; when writing a SKILL.md that should be flesh-dense and bone-sparse; or when checking whether a compression deleted negation, order, quantifier, operator, named object, value, decision, or unresolved hmmm. Historical bone/flesh and text-stack terminology is local compression notation, not a UCNS theorem/status transfer, active language-construction authority, or edcmbone metric implementation.", + "name": "char-compress" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "536e878e7ad79c650cb515930d3579c0c6efcd648f2aa14c551d8cfcaade53c5", + "file": "skills/char-compress/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/char-compress/SKILL.md#subject/document/skills%2Fchar-compress%2FSKILL.md", + "identity": "skills/char-compress/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/data-visualization/SKILL.md#subject/document/skills%2Fdata-visualization%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Create effective data visualizations with Python (matplotlib, seaborn, plotly). Use this when building charts, choosing the right chart type for a dataset, creating publication-quality figures, or applying design principles like accessibility and color theory.", + "name": "data-visualization" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "f4a240b27c3f0d01c79d4d38528c0362225d4ae3169978fb14155623a05d2b77", + "file": "skills/data-visualization/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/data-visualization/SKILL.md#subject/document/skills%2Fdata-visualization%2FSKILL.md", + "identity": "skills/data-visualization/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/deps-build/SKILL.md#subject/document/skills%2Fdeps-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first dependency topology built on msdmd. Consume imports, package manifests, lockfiles and build declarations at their owning scopes; supplemental DEPENDENCIES blocks express remaining architectural intent. Preserve edge kinds, conditions and resolution uncertainty. Load this when declaring dependencies, auditing architecture drift, checking graph cycles, or wiring dependency topology checks into CI.", + "name": "deps-build" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "5356ccde0cc29c3b9d34e190b969a59eb16384f6d38d0c39a61be082e6e5a5d3", + "file": "skills/deps-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/deps-build/SKILL.md#subject/document/skills%2Fdeps-build%2FSKILL.md", + "identity": "skills/deps-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/distributed-publication/SKILL.md#subject/document/skills%2Fdistributed-publication%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Provenance-bearing publication from distributed source owners. Load this when assembling, displaying, or maintaining one ordered textbook, report, standard, corpus, archive, knowledge surface, or public reading sequence whose authoritative units live in multiple repositories or independently owned files; when a publication consumer must retrieve exact commits, blobs, and content digests; when source order, source-local license or status, explicit fallback, correction routing, or public build identity must remain intact. Load interdependent-work-graph with it. Do not load for ordinary single-repository documentation, a link index that does not reproduce source content, or cross-repository code coordination with no publication artifact.", + "name": "distributed-publication" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "1efb32e2960b05f7212e7792431a53c41c8525b2c294fe3aa8734e08414e7f78", + "file": "skills/distributed-publication/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/distributed-publication/SKILL.md#subject/document/skills%2Fdistributed-publication%2FSKILL.md", + "identity": "skills/distributed-publication/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/doc-build/SKILL.md#subject/document/skills%2Fdoc-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first documentation coverage built on msdmd. Consume docstrings, documentation comments and source-linked documents; supplemental DOCS blocks express remaining obligations. A consuming runner verifies references and reports missing information separately from unsupported extraction. Load this when adding or auditing module documentation, tying code surfaces to docs, or wiring documentation coverage checks into CI.", + "name": "doc-build" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "6b98243348d649298f82d12e4d10556422ea8917b529aa5476767bae35f06957", + "file": "skills/doc-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/doc-build/SKILL.md#subject/document/skills%2Fdoc-build%2FSKILL.md", + "identity": "skills/doc-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/domain-claims/SKILL.md#subject/document/skills%2Fdomain-claims%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Domain-first lexical and semantic governance for canonical terms. Load this when a word or phrase is being promoted into a theorem term, ontology primitive, schema field, encoding label, skill doctrine, cross-domain mapping, or other meaning-bearing control surface; when multiple domains use the same word differently; when an acronym, initialism, symbol, or compact handle is being mistaken for a fixed expansion or definition; or when conversational provenance is about to be attached to a definition. Do not load for ordinary prose, casual wording choices, or simple dictionary explanations that will not control canon or structure.", + "name": "domain-claims" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "1b25bc106d38e3d697923ab13951f5fb257ac84aff496c970e87c122104e9500", + "file": "skills/domain-claims/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/domain-claims/SKILL.md#subject/document/skills%2Fdomain-claims%2FSKILL.md", + "identity": "skills/domain-claims/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/epac-selection-display/SKILL.md#subject/document/skills%2Fepac-selection-display%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Evidence-bound EPAC target selection and display for WebMCP handoffs and other human-facing surfaces. Load this when choosing an EPAC element, molecule, construction receipt, comparison result, or available visualization to present; when preparing a receipt-backed EPAC display packet; when exposing the EPAC workflow as a selectable WebMCP skill; or when a requested EPAC display would require missing or invented geometry so the request can be refused or downgraded to verified source-backed output. Do not load to select EPAC or a UCNS candidate as canon, or for unrelated WebMCP catalogue changes.", + "name": "epac-selection-display" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "ba980124fad706570f64f79e8549d37da7d284c6364471ef5f5cb42c05bc338d", + "file": "skills/epac-selection-display/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/epac-selection-display/SKILL.md#subject/document/skills%2Fepac-selection-display%2FSKILL.md", + "identity": "skills/epac-selection-display/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/explore-data/SKILL.md#subject/document/skills%2Fexplore-data%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Profile and explore a dataset to understand its shape, quality, and patterns. Use this when encountering a new table or file, checking null rates and column distributions, spotting data quality issues like duplicates or suspicious values, or deciding which dimensions and metrics to analyze.", + "name": "explore-data" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "bc113123417f8f0cb1b57c993c24bc1763d94333d6a7677384e20dca4931d36d", + "file": "skills/explore-data/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/explore-data/SKILL.md#subject/document/skills%2Fexplore-data%2FSKILL.md", + "identity": "skills/explore-data/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/fresh-making/SKILL.md#subject/document/skills%2Ffresh-making%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Deterministic restoration of derived-artifact consistency after authoritative inputs change. Load this when deciding whether generated or derived outputs are current; when regenerating MSDMD collections, documentation, projections, package indexes, calibration artifacts, or other outputs from exact source identities; when computing the minimum affected rebuild closure; when designing retryable regeneration across unreliable executors; or when a system needs to make artifacts provably fresh rather than merely recently rebuilt. Do not load for ordinary one-shot builds whose inputs and outputs have no persistent freshness contract.", + "name": "fresh-making" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "2b09c65531ccd39a7955011e613887917e63713cb06f8327841c2a2e54216060", + "file": "skills/fresh-making/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/fresh-making/SKILL.md#subject/document/skills%2Ffresh-making%2FSKILL.md", + "identity": "skills/fresh-making/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/gonol-build/SKILL.md#subject/document/skills%2Fgonol-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Construction, closure, and replay discipline for active gonol-language research. Load this when building or reviewing language constructions made from UCNS gonol objects in The-Interdependency/stack, or when checking closure, atomic participation, provenance, replay, and unresolved geometry boundaries. UCNS owns gonol objects, constructors, and geometry; Stack owns active construction research; EDCM owns measurement/evaluation only. Closed gonols participate atomically at admissible consuming scales; no universal adjacent-scale ladder is required. Pronunciation is not required unless an explicitly declared construction makes it part of the build. Do not load for unrelated geometry, ordinary prose editing, or measurement over already-closed gonols.", + "name": "gonol-build" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "80f641582e683bed0040c6ce3c21e19236a8534e031bc633487ca20169f6d4c2", + "file": "skills/gonol-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/gonol-build/SKILL.md#subject/document/skills%2Fgonol-build%2FSKILL.md", + "identity": "skills/gonol-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/interdependent-work-graph/SKILL.md#subject/document/skills%2Finterdependent-work-graph%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Cross-repository coordination for The Interdependency. Load this when a task spans, consumes, compares, publishes to, or can change the contract between two or more repositories; when an agent is about to choose one repo as its workspace for a stack-level problem; when exact producer, evidence-source, skill, semantic, mathematical, or measurement identities must travel together; or when creating a shared stack manifest, multi-repo handoff, coordinated release, or cross-repo validation plan.", + "name": "interdependent-work-graph" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "6e27e3c4f3b06bd1bb5875b49ca1c29bd5db80ef2d7bce0a89f6aa6f54b7dc04", + "file": "skills/interdependent-work-graph/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/interdependent-work-graph/SKILL.md#subject/document/skills%2Finterdependent-work-graph%2FSKILL.md", + "identity": "skills/interdependent-work-graph/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/llms-build/SKILL.md#subject/document/skills%2Fllms-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first LLM instruction publication built on msdmd. Consume source-owned instruction metadata without requiring a second copy; the shipped stdlib runner generates llms.txt from LLMS blocks, while native-reader integration remains a contract. Load this when creating, updating, or maintaining llms.txt for repositories consumed by LLMs or agents.", + "name": "llms-build" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "df9e4a651b893da1e2395047646b3fe12f9f7acfeebb28c466092a033cdd59fe", + "file": "skills/llms-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/llms-build/SKILL.md#subject/document/skills%2Fllms-build%2FSKILL.md", + "identity": "skills/llms-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/loop-eng/SKILL.md#subject/document/skills%2Floop-eng%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Loop engineering for designing closed feedback cycles (Discover→Plan→Execute→Verify→Iterate), single-agent and fleet loops with subagent maker/checker separation, and automated verify-iterate workflows. Load this when building or orchestrating agent systems (a0p, AIMMH), EDCMBONE analysis pipelines, repeatable AI workflows, or any The-Interdependency project that benefits from structured loops instead of manual prompting. Cross-load with the-interdependency for org workflow context.", + "name": "loop-eng" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "3599cefdf7545ef5ee1383002890697577d20e2565526e8cf303b5c223dc3d39", + "file": "skills/loop-eng/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/loop-eng/SKILL.md#subject/document/skills%2Floop-eng%2FSKILL.md", + "identity": "skills/loop-eng/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/manifest/SKILL.md#subject/document/skills%2Fmanifest%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Living-spec generator. Derives the mechanical, observable facts of a repo (package name, version, description, license, authors, repository, build backend, development status, supported Python versions, keywords, runtime dependencies, optional extras, top-level layout, CI workflows) from pyproject.toml + the file tree and splices them into a machine-owned, marked block inside CLAUDE.md — keeping the doc from silently drifting from the code. Ships a stdlib-only generator with --write (refresh), --check (CI drift gate), and --print modes. Load this when: setting up or maintaining a CLAUDE.md / AGENTS.md so its factual half is generated rather than hand-typed; wiring a CI check that fails when docs drift from pyproject/version/deps/layout; deciding which parts of a doc to generate vs. hand-author; or onboarding a new org repo to the living-spec convention.", + "name": "manifest" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "8fa8474c6ea92aba000212a9afcb687ee6d412914442f92c0de9c9fb10d008ab", + "file": "skills/manifest/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/manifest/SKILL.md#subject/document/skills%2Fmanifest%2FSKILL.md", + "identity": "skills/manifest/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/meta-module-build/SKILL.md#subject/document/skills%2Fmeta-module-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first module planning built on msdmd. Consume existing manifests, schemas and design declarations; supplemental MODULE_BUILD blocks record remaining purpose, surface, boundary, test, rollout and rollback obligations. Load this when turning a capability idea into a bounded module manifest and file plan before implementation.", + "name": "meta-module-build" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "477040eeb318d17c5d8532c1ca4245f64626c6b60d3354588753b48ef866f1a9", + "file": "skills/meta-module-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/meta-module-build/SKILL.md#subject/document/skills%2Fmeta-module-build%2FSKILL.md", + "identity": "skills/meta-module-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/meta/SKILL.md#subject/document/skills%2Fmeta%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "METAPAT consultation router for The Interdependency. Load this when deciding which distinctions, relations, boundaries, transformations, scales, or cross-domain correspondences should organize downstream work; when examining available observations or metrics to determine which questions and projections are worth measuring; when the-interdependency skill's METAPAT consultation gate triggers; when an unresolved conceptual choice would constrain architecture, semantics, measurement, ontology, or later claims; or when explicitly asked to consult, apply, or interpret current METAPAT. Do not load merely for routine implementation under already-fixed conceptual contracts.", + "name": "meta" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "a721ce8c37f8aeccacd07f41854d154edb44695da637452aec3dbf64c6af38b3", + "file": "skills/meta/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/meta/SKILL.md#subject/document/skills%2Fmeta%2FSKILL.md", + "identity": "skills/meta/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/msdmd/SKILL.md#subject/document/skills%2Fmsdmd%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Module Self-Declared Metadata in Markdown — native-first collection of metadata already expressed by code, documentation, manifests, schemas, tooling, and evidence formats, with MSDMD blocks only for otherwise unexpressed information. Load this when creating or revising metadata-driven skills, collecting repository metadata, integrating a metadata convention, building parsers or collection consumers, or auditing metadata coverage and provenance.", + "name": "msdmd" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "93ad71f5b4b692e219b42eba5df07c0caba541f9d3b0fa8cd4a80d0b0945d49b", + "file": "skills/msdmd/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/msdmd/SKILL.md#subject/document/skills%2Fmsdmd%2FSKILL.md", + "identity": "skills/msdmd/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/owner-build/SKILL.md#subject/document/skills%2Fowner-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first module stewardship built on msdmd. Consume provider-specific CODEOWNERS, OWNERS and other authoritative responsibility declarations; supplemental OWNERS blocks express missing stewardship or escalation information. Keep review assignment, operational ownership and permissions distinct. Load this when assigning module ownership, routing reviews, auditing unowned code, or wiring stewardship coverage into CI.", + "name": "owner-build" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "b9ee2c381e1f3fe330abd59758f5b5466d7bf88d58e35193a4b4f6114b5466ad", + "file": "skills/owner-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/owner-build/SKILL.md#subject/document/skills%2Fowner-build%2FSKILL.md", + "identity": "skills/owner-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/plain-lens/SKILL.md#subject/document/skills%2Fplain-lens%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Building a plain-language, multi-lens companion view of dense canonical text — an easier on-ramp that does not replace or talk down to the source. Load this when you are asked to make an informationally dense document (canon, spec, articles, legal/normative text) easier to approach for newcomers; when building an \"explain it through the lens of X\" selector (domain, audience, or role); when designing progressive-disclosure or layered ELI-not-stupid reading UX; when a dynamic, data-driven site must keep its existing static page as a graceful fallback; or when you need an EDCM-style two-speaker tension reading between a body text and its footnotes/caveats. Use this when the risk is either drowning readers in density or insulting them with oversimplification.", + "name": "plain-lens" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "e502bfcaee33b1a6a7f30fc953e94993ad4667a4da765c70fd2323dbe2c85212", + "file": "skills/plain-lens/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/plain-lens/SKILL.md#subject/document/skills%2Fplain-lens%2FSKILL.md", + "identity": "skills/plain-lens/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/project-incubation-graduation/SKILL.md#subject/document/skills%2Fproject-incubation-graduation%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Project incubation and graduation doctrine for emergent components born inside an integration, stack, laboratory, or incubator repository. Load this when several existing projects compose into a new candidate capability; when assessing whether that candidate should remain incubated or become its own repository/package; when extracting it with provenance; when establishing a new implementation authority boundary; when publishing the extracted project through a registry such as PyPI; or when making the former incubator consume the released artifact instead of its local copy. Do not load for an ordinary new repository with no incubation history or for a routine package release whose authority boundary is already established.", + "name": "project-incubation-graduation" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "65cba655c532c341452c46d2aa4bf3182e6e4a7a17bc53ee65872395336f48f0", + "file": "skills/project-incubation-graduation/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/project-incubation-graduation/SKILL.md#subject/document/skills%2Fproject-incubation-graduation%2FSKILL.md", + "identity": "skills/project-incubation-graduation/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/ratios/SKILL.md#subject/document/skills%2Fratios%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Self-declaring module composition ratios on msdmd — one comment line at a file's opening and closing source boundaries (never a fenced block), with a valid interpreter shebang allowed before the opening seal. The canonical seal is `The-Interdependency/a0`'s compact positional `N:M C:D I:O` annotation (code:comment · consumed:declared · fan-in:fan-out), computed by a0's `scripts/annotate.py`; the named `loc_comments=… imports_exports=… calls_definitions=…` line is a portable, per-file adaptation for standalone libraries, verified by the stdlib `ratios_check.py` (drift/misplacement failures, visible gaps). JSON/Markdown are out of scope. Load this when recording a module's composition ratios, when authoring or extending the ratio registry, or when wiring ratio verification into CI.", + "name": "ratios" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff73c3f8d798f35df287b5adfdee54fa0585ac96993d0938317cff906231b551", + "file": "skills/ratios/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/ratios/SKILL.md#subject/document/skills%2Fratios%2FSKILL.md", + "identity": "skills/ratios/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/repo-audit-repair/SKILL.md#subject/document/skills%2Frepo-audit-repair%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Evidence-led repository audit and repair from exact repository identity through authoritative verification. Use this when asked to audit, assess, harden, clean up, or audit and repair an existing code repository; when a green build may conceal placeholder gates, deprecated paths, or partial publication; or when repair must distinguish repository defects from environment, external-service, policy, and unresolved conditions. Do not load for an ordinary fixed-scope edit, a narrow review, or diagnosis of one already-localized failure unless the user requests a broader repository audit.", + "name": "repo-audit-repair" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "dbab49c237a2e87d81adc3c47e96270664472a4b559fe9a5fa2416bd2a6bd85a", + "file": "skills/repo-audit-repair/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/repo-audit-repair/SKILL.md#subject/document/skills%2Frepo-audit-repair%2FSKILL.md", + "identity": "skills/repo-audit-repair/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/risk-boundary-build/SKILL.md#subject/document/skills%2Frisk-boundary-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first runtime risk and permission boundaries built on msdmd. Consume existing permission, schema, configuration and effect declarations; supplemental BOUNDARIES blocks express otherwise missing auth, storage, network, user-data and operational effects. Declarations do not prove enforcement. Load this when touching permissions, persistence, network calls, user data, admin behavior, migrations, or other risk-bearing effects.", + "name": "risk-boundary-build" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "03494ed2a58138903ea569d663bce19de8efb27e489df67394a739caa337223c", + "file": "skills/risk-boundary-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/risk-boundary-build/SKILL.md#subject/document/skills%2Frisk-boundary-build%2FSKILL.md", + "identity": "skills/risk-boundary-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/skill-build/SKILL.md#subject/document/skills%2Fskill-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Skill authoring and skill compliance workflow for The Interdependency skill-lib. Load this when creating a new SKILL.md, revising an existing skill, bringing repo skills into a shared compliance shape, designing a skill-specific test suite, deciding whether a skill is metadata-block or procedural, or asking the question set required before a skill can be accepted.", + "name": "skill-build" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "45cafced18a804c9c3ef9a082a9deff9c52e4c641f0ea59b3ef97d33fef473e5", + "file": "skills/skill-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/skill-build/SKILL.md#subject/document/skills%2Fskill-build%2FSKILL.md", + "identity": "skills/skill-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/skill-usage/SKILL.md#subject/document/skills%2Fskill-usage%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Record and report evidence-bearing usage maturity for skills installed from The Interdependency skill-lib. Load this when any other skill-lib skill is invoked, and when asked for skill counts, usage history, maturity, reliability, experimental status, field-test status, operational status, or daily-use status.", + "name": "skill-usage" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "d7446ed118846f82fe63524e171eee599f6001447749f3f1da2d141d5a62a456", + "file": "skills/skill-usage/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/skill-usage/SKILL.md#subject/document/skills%2Fskill-usage%2FSKILL.md", + "identity": "skills/skill-usage/SKILL.md", + "scope": "document" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/sql-queries/SKILL.md#subject/document/skills%2Fsql-queries%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Write correct, performant SQL across all major data warehouse dialects (Snowflake, BigQuery, Databricks, PostgreSQL, etc.). Use this when writing queries, optimizing slow SQL, translating between dialects, or building complex analytical queries with CTEs, window functions, or aggregations.", + "name": "sql-queries" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "4f0b660ee647329ea77900243caf737f678c959fb46d0cddcec2ba8597e55f8e", + "file": "skills/sql-queries/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/sql-queries/SKILL.md#subject/document/skills%2Fsql-queries%2FSKILL.md", + "identity": "skills/sql-queries/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/ssh-automation/SKILL.md#subject/document/skills%2Fssh-automation%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Fail-closed SSH automation and shell-script delivery for OpenSSH and Google Cloud. Load this when writing, reviewing, or troubleshooting non-interactive SSH scripts, CI/CD remote commands, scp/sftp/rsync-over-SSH workflows, Google Cloud IAP or OS Login automation, remote heredocs, host-key bootstrap, retries and timeouts, or one-box Cloud Shell commands that must not terminate the user's interactive shell. Do not load for one-off interactive login, server-side sshd hardening alone, or MCP-based VM control planes.", + "name": "ssh-automation" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "7a3e6c5d07df0e4e84da48efb2d7ff38bac1ac7c83f29af10155ebb8f566b45e", + "file": "skills/ssh-automation/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/ssh-automation/SKILL.md#subject/document/skills%2Fssh-automation%2FSKILL.md", + "identity": "skills/ssh-automation/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/stack-update/SKILL.md#subject/document/skills%2Fstack-update%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Fail-closed update protocol for The-Interdependency/stack. Load this when a stack change adds, moves, extracts, graduates, renames, removes, or changes the authority, relation, source identity, or placement of a participant, research workspace, libs pin, BASE record, stack manifest entry, or architecture description; when stack-manifest.json, STACK_MANIFEST.md, README.md, or research BASE.json files may drift from one another; or when validating that a structural stack change is complete before commit or merge.", + "name": "stack-update" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "f9ec13061c7003b58f49ca2f595489d3f15b40c13cc710f69dda915038864d32", + "file": "skills/stack-update/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/stack-update/SKILL.md#subject/document/skills%2Fstack-update%2FSKILL.md", + "identity": "skills/stack-update/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/statistical-analysis/SKILL.md#subject/document/skills%2Fstatistical-analysis%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Apply statistical methods including descriptive stats, trend analysis, outlier detection, and hypothesis testing. Use this when analyzing distributions, testing for significance, detecting anomalies, computing correlations, or interpreting statistical results.", + "name": "statistical-analysis" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "8862fda54003b4e0c428506a472c945d8617426a261eabac5d1c111bd2b76403", + "file": "skills/statistical-analysis/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/statistical-analysis/SKILL.md#subject/document/skills%2Fstatistical-analysis%2FSKILL.md", + "identity": "skills/statistical-analysis/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/test-build/SKILL.md#subject/document/skills%2Ftest-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first contract evidence built on msdmd. Source owners declare behavior obligations and test owners declare accountable witnesses through supported native conventions or supplemental CONTRACTS and CHECKS blocks. Preserve explicit claim linkage and no-exec audit boundaries. Load this when adding tests that use msdmd, refactoring CONTRACTS/CHECKS declarations, or authoring a contract/check audit or executor.", + "name": "test-build" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "3aff88b8d87efac6833b31f4d4a5da44329f737578f6083c1864641551487976", + "file": "skills/test-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/test-build/SKILL.md#subject/document/skills%2Ftest-build%2FSKILL.md", + "identity": "skills/test-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/the-interdependency/SKILL.md#subject/document/skills%2Fthe-interdependency%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Protocol and workflow for all tasks involving The Interdependency organization, its repositories, The Interdependent Way projects, EDCMBONE transcript analysis, code building, research, GitHub maintenance and updates. Load this whenever the task or context touches The-Interdependency assets, or on phrases like \"assemble edcmbone transcripts for analysis\", \"write code that...\", or any GitHub/research/build work on org projects.", + "name": "the-interdependency" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "a04d14626527dd8130404c0ff49645cf4f538e0db59b695e6a5d0ca0b2879b79", + "file": "skills/the-interdependency/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/the-interdependency/SKILL.md#subject/document/skills%2Fthe-interdependency%2FSKILL.md", + "identity": "skills/the-interdependency/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/thought-lens/SKILL.md#subject/document/skills%2Fthought-lens%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Translate raw, context-heavy, recursive, fragmentary, coined, or private-language thought into audience-legible language without changing the underlying claim. Load this when a user says people do not understand what they mean; asks to make a thought understandable to strangers, the public, a specific audience, or a platform; supplies dense notes rather than finished prose; needs jargon or coined terms introduced only after their ordinary-language meaning lands; or wants multiple audience/surface renderings from one thought. Do not load merely to polish finished prose or to simplify an already-stable canonical document; use ordinary editing for the former and plain-lens for the latter.", + "name": "thought-lens" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "1ff29ce52ad6e6796e87ec39af9ca13dbcc8dac3b52792ac107b9eef0ece2613", + "file": "skills/thought-lens/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/thought-lens/SKILL.md#subject/document/skills%2Fthought-lens%2FSKILL.md", + "identity": "skills/thought-lens/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/typed-meta-frontend/SKILL.md#subject/document/skills%2Ftyped-meta-frontend%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "TypeScript frontend generation from backend-owned module metadata and living specs. Load this when building, reviewing, or refactoring a self-building UI that reads backend metadata, exposes every editable field per module, renders each module's living spec, generates TypeScript types/forms/routes from metadata, or keeps admin/editor frontends synchronized with msdmd-style source declarations.", + "name": "typed-meta-frontend" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "2e2ecc7e280076510fd900d976719ecccacd13b2fead3997b8b02fc86dc5001d", + "file": "skills/typed-meta-frontend/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/typed-meta-frontend/SKILL.md#subject/document/skills%2Ftyped-meta-frontend%2FSKILL.md", + "identity": "skills/typed-meta-frontend/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/ucns-option-selection/SKILL.md#subject/document/skills%2Fucns-option-selection%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Fail-closed rubric for comparing, retaining, rejecting, deprecating, and selecting UCNS options within an explicit scope. Load this when an agent asks which UCNS candidate should win, whether evidence authorizes selection, how an option moves from registered or implemented to selected, how to compare competing gonol constructors, carriers, geometries, policies, projections, or measurement candidates, or how to issue a scoped UCNS decision receipt. Do not load merely to register options, execute one already-selected option, or choose ordinary UI preferences. Never select universal UCNS canon by score, familiarity, implementation order, or EDCM-local evidence.", + "name": "ucns-option-selection" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "b08fa7f7662af281209e16343137bd94b970e29433474b0b955512f1f53e9f5d", + "file": "skills/ucns-option-selection/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/ucns-option-selection/SKILL.md#subject/document/skills%2Fucns-option-selection%2FSKILL.md", + "identity": "skills/ucns-option-selection/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/validate-data/SKILL.md#subject/document/skills%2Fvalidate-data%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "QA an analysis before sharing -- methodology, accuracy, and bias checks. Use this when reviewing an analysis before a stakeholder presentation, spot-checking calculations and aggregation logic, verifying a SQL query's results look right, or assessing whether conclusions are actually supported by the data.", + "name": "validate-data" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "76c3dc536b6fcf18aaa62a10137405e78e96e2098072cd70756fd2706cf18d44", + "file": "skills/validate-data/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/validate-data/SKILL.md#subject/document/skills%2Fvalidate-data%2FSKILL.md", + "identity": "skills/validate-data/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/visitor-intro/SKILL.md#subject/document/skills%2Fvisitor-intro%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Onboarding tour for visitors arriving at any The-Interdependency repo. Load this when an unfamiliar user asks \"what is this?\", \"what is The Interdependency?\", \"how do these repos fit together?\", \"where do I start?\", or otherwise signals they are new to the org. Gives the agent a consistent, repo-aware way to orient a newcomer without inventing facts.", + "name": "visitor-intro" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "bec444a3baa4f713fea1c0ed46cf8233fb95ba3c9f599d5b19a0651e95a127cc", + "file": "skills/visitor-intro/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/visitor-intro/SKILL.md#subject/document/skills%2Fvisitor-intro%2FSKILL.md", + "identity": "skills/visitor-intro/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/vm-mcp/SKILL.md#subject/document/skills%2Fvm-mcp%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Private VM control-plane skill for giving an AI/MCP client SSH-like access to a Linux or Google Compute Engine VM without handing the client an SSH private key. Load this when a user asks to connect ChatGPT, an OpenAI client, Codex, Claude, or another MCP host to a VM; expose bounded shell/file tools on a private VM; replace repeated human SSH with an auditable MCP control plane; install or audit the shipped vm-mcp runtime; or add narrowly scoped administrative actions above the workspace shell. Do not load for ordinary human-only SSH setup with no MCP/agent access.", + "name": "vm-mcp" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "17f6412b4492bf8564f0a56c9e8bb7189c420c18cf88ac74cfda1b3dba47271c", + "file": "skills/vm-mcp/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/vm-mcp/SKILL.md#subject/document/skills%2Fvm-mcp%2FSKILL.md", + "identity": "skills/vm-mcp/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/website-builder-journal/SKILL.md#subject/document/skills%2Fwebsite-builder-journal%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Load this when any modification to The-Interdependency/The-Interdependency.github.io is planned or underway, including source, content, configuration, tests, workflows, dependencies, generated-contract code, or deployment paths. Every website change transaction must append at least one By the builder entry recording date, time, and the exact runtime model; the model chooses the subject and writes no more than needed to explicate it. Do not load for read-only inspection that changes no website file.", + "name": "website-builder-journal" + }, + "generated": true, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "c28aea4e5fb25133074e2e07d5e814259838f26f1c9d452e76c53986c33e5b0f", + "file": "skills/website-builder-journal/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "derived", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/skills/website-builder-journal/SKILL.md#subject/document/skills%2Fwebsite-builder-journal%2FSKILL.md", + "identity": "skills/website-builder-journal/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/sql-queries/SKILL.md#subject/document/sql-queries%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Write correct, performant SQL across all major data warehouse dialects (Snowflake, BigQuery, Databricks, PostgreSQL, etc.). Use this when writing queries, optimizing slow SQL, translating between dialects, or building complex analytical queries with CTEs, window functions, or aggregations.", + "name": "sql-queries" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "110164773d0f5daf458031c4464f8eeb3b1a18c96c71ed876b97c10c772dd923", + "file": "sql-queries/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/sql-queries/SKILL.md#subject/document/sql-queries%2FSKILL.md", + "identity": "sql-queries/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ssh-automation/SKILL.md#subject/document/ssh-automation%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Fail-closed SSH automation and shell-script delivery for OpenSSH and Google Cloud. Load this when writing, reviewing, or troubleshooting non-interactive SSH scripts, CI/CD remote commands, scp/sftp/rsync-over-SSH workflows, Google Cloud IAP or OS Login automation, remote heredocs, host-key bootstrap, retries and timeouts, or one-box Cloud Shell commands that must not terminate the user's interactive shell. Do not load for one-off interactive login, server-side sshd hardening alone, or MCP-based VM control planes.", + "name": "ssh-automation" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "f62e9280947853eba77e2b9df22fb5a45491afd39b52f6f09dc728717ddb55c8", + "file": "ssh-automation/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ssh-automation/SKILL.md#subject/document/ssh-automation%2FSKILL.md", + "identity": "ssh-automation/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/stack-update/SKILL.md#subject/document/stack-update%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Fail-closed update protocol for The-Interdependency/stack. Load this when a stack change adds, moves, extracts, graduates, renames, removes, or changes the authority, relation, source identity, or placement of a participant, research workspace, libs pin, BASE record, stack manifest entry, or architecture description; when stack-manifest.json, STACK_MANIFEST.md, README.md, or research BASE.json files may drift from one another; or when validating that a structural stack change is complete before commit or merge.", + "name": "stack-update" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "a708557f486f638cd1204af66ea8d268c498bcd840c240f869eeb1ebace9eb1c", + "file": "stack-update/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/stack-update/SKILL.md#subject/document/stack-update%2FSKILL.md", + "identity": "stack-update/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/statistical-analysis/SKILL.md#subject/document/statistical-analysis%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Apply statistical methods including descriptive stats, trend analysis, outlier detection, and hypothesis testing. Use this when analyzing distributions, testing for significance, detecting anomalies, computing correlations, or interpreting statistical results.", + "name": "statistical-analysis" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "a4276f17940d9a8026325ef40055717be34139137a77ca63b0222df98d6229c4", + "file": "statistical-analysis/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/statistical-analysis/SKILL.md#subject/document/statistical-analysis%2FSKILL.md", + "identity": "statistical-analysis/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/test-build/SKILL.md#subject/document/test-build%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Native-first contract evidence built on msdmd. Source owners declare behavior obligations and test owners declare accountable witnesses through supported native conventions or supplemental CONTRACTS and CHECKS blocks. Preserve explicit claim linkage and no-exec audit boundaries. Load this when adding tests that use msdmd, refactoring CONTRACTS/CHECKS declarations, or authoring a contract/check audit or executor.", + "name": "test-build" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "d50de734dbd19e9af97287952016d1263aab4b6f2e8935f2b67bc4255471ef1e", + "file": "test-build/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/test-build/SKILL.md#subject/document/test-build%2FSKILL.md", + "identity": "test-build/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/fixtures/distributed_publication_manifest.json#subject/document/tests%2Ffixtures%2Fdistributed_publication_manifest.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "json.document", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "boundaries": { + "authorship_transfer": false, + "canonical_status_transfer": false, + "certification_status_transfer": false, + "digest_is_authentication": false, + "empirical_status_transfer": false, + "hmmm": [], + "license_transfer": false, + "measurement_status_transfer": false, + "ownership_transfer": false, + "proof_status_transfer": false + }, + "consumer": { + "commit": "7777777777777777777777777777777777777777", + "fallback_policy": "fail-closed-production|explicit-retained-snapshot", + "renderer": "exact-markdown-static", + "repository": "example/publication", + "route_prefix": "/publication/" + }, + "order_is_load_bearing": true, + "publication_id": "fixture-publication", + "publication_sha256": "hmmm", + "schema": "the-interdependency.distributed-publication", + "sources": [ + { + "authority": "first source", + "blob": "2222222222222222222222222222222222222222", + "commit": "1111111111111111111111111111111111111111", + "content_sha256": "3333333333333333333333333333333333333333333333333333333333333333", + "correction_target": "example/first:FIRST.md", + "expected_title": "First source", + "fallback": false, + "license": "MPL-2.0", + "license_status": "declared", + "path": "FIRST.md", + "position": 0, + "repository": "example/first", + "source_id": "first", + "status": "declared" + }, + { + "authority": "second source", + "blob": "5555555555555555555555555555555555555555", + "commit": "4444444444444444444444444444444444444444", + "content_sha256": "6666666666666666666666666666666666666666666666666666666666666666", + "correction_target": "example/second:SECOND.md", + "expected_title": "Second source", + "fallback": false, + "license": "hmmm", + "license_status": "unknown", + "path": "SECOND.md", + "position": 1, + "repository": "example/second", + "source_id": "second", + "status": "frontier" + } + ], + "title": "Fixture publication", + "version": "1.0.0" + } + }, + "origin": "native", + "source": { + "content_sha256": "dd3917c47dc9380158c4b35f8e2eaf3d01d0d5c5394c1f303580dd249884714d", + "file": "tests/fixtures/distributed_publication_manifest.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/fixtures/distributed_publication_manifest.json#subject/document/tests%2Ffixtures%2Fdistributed_publication_manifest.json", + "identity": "tests/fixtures/distributed_publication_manifest.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/frontmatter.py#subject/module/tests%2Ffrontmatter.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "718290b7331141391e8e02f6f1c3a18bfc1ed60fb7909b0ec3330241b42c044e", + "file": "tests/frontmatter.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/frontmatter.py#subject/module/tests%2Ffrontmatter.py", + "identity": "tests/frontmatter.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/frontmatter.py#subject/module/tests%2Ffrontmatter.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "718290b7331141391e8e02f6f1c3a18bfc1ed60fb7909b0ec3330241b42c044e", + "file": "tests/frontmatter.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/frontmatter.py#subject/module/tests%2Ffrontmatter.py", + "identity": "tests/frontmatter.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/frontmatter.py#subject/symbol/frontmatter_for/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "frontmatter_for", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/frontmatter.py::function:frontmatter_for", + "decorators": [], + "kind": "function", + "name": "frontmatter_for", + "parent_identity": null, + "qualified_name": "frontmatter_for", + "signature": "def frontmatter_for(path: Path) -> dict[str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "718290b7331141391e8e02f6f1c3a18bfc1ed60fb7909b0ec3330241b42c044e", + "file": "tests/frontmatter.py", + "location": { + "end_line": 45, + "span": { + "end": { + "byte": 1453, + "column": 15, + "line": 45 + }, + "start": { + "byte": 63, + "column": 0, + "line": 6 + } + }, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/frontmatter.py#subject/symbol/frontmatter_for", + "identity": "frontmatter_for", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/frontmatter.py#subject/symbol/frontmatter_for/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/frontmatter.py::function:frontmatter_for", + "description": "The tests intentionally stay dependency-free, but descriptions may use\nfolded YAML scalars (``description: >-``), so a line-by-line ``key: value``\nsplit is not enough for the public load-trigger contract.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Parse the small YAML frontmatter subset used by SKILL.md files.", + "text": "Parse the small YAML frontmatter subset used by SKILL.md files.\n\n The tests intentionally stay dependency-free, but descriptions may use\n folded YAML scalars (``description: >-``), so a line-by-line ``key: value``\n split is not enough for the public load-trigger contract.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "718290b7331141391e8e02f6f1c3a18bfc1ed60fb7909b0ec3330241b42c044e", + "file": "tests/frontmatter.py", + "location": { + "end_line": 12, + "span": { + "end": { + "byte": 410, + "column": 7, + "line": 12 + }, + "start": { + "byte": 118, + "column": 4, + "line": 7 + } + }, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/frontmatter.py#subject/symbol/frontmatter_for", + "identity": "frontmatter_for", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py", + "identity": "tests/test_action_calibration_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py", + "identity": "tests/test_action_calibration_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py", + "identity": "tests/test_action_calibration_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py", + "identity": "tests/test_action_calibration_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "frontmatter:frontmatter_for:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "frontmatter", + "name": "frontmatter_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/module/tests%2Ftest_action_calibration_skill.py", + "identity": "tests/test_action_calibration_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ActionCalibrationSkillTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::method:ActionCalibrationSkillTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::class:ActionCalibrationSkillTest", + "qualified_name": "ActionCalibrationSkillTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 24, + "span": { + "end": { + "byte": 883, + "column": 66, + "line": 24 + }, + "start": { + "byte": 572, + "column": 4, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.setUp", + "identity": "ActionCalibrationSkillTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_activation_and_non_trigger_are_concrete/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ActionCalibrationSkillTest.test_activation_and_non_trigger_are_concrete", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::method:ActionCalibrationSkillTest.test_activation_and_non_trigger_are_concrete", + "decorators": [], + "kind": "method", + "name": "test_activation_and_non_trigger_are_concrete", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::class:ActionCalibrationSkillTest", + "qualified_name": "ActionCalibrationSkillTest.test_activation_and_non_trigger_are_concrete", + "signature": "def test_activation_and_non_trigger_are_concrete(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 38, + "span": { + "end": { + "byte": 1451, + "column": 50, + "line": 38 + }, + "start": { + "byte": 889, + "column": 4, + "line": 26 + } + }, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_activation_and_non_trigger_are_concrete", + "identity": "ActionCalibrationSkillTest.test_activation_and_non_trigger_are_concrete", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_audit_creates_one_skill_and_routes_adjacent_patterns/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ActionCalibrationSkillTest.test_audit_creates_one_skill_and_routes_adjacent_patterns", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::method:ActionCalibrationSkillTest.test_audit_creates_one_skill_and_routes_adjacent_patterns", + "decorators": [], + "kind": "method", + "name": "test_audit_creates_one_skill_and_routes_adjacent_patterns", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::class:ActionCalibrationSkillTest", + "qualified_name": "ActionCalibrationSkillTest.test_audit_creates_one_skill_and_routes_adjacent_patterns", + "signature": "def test_audit_creates_one_skill_and_routes_adjacent_patterns(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 107, + "span": { + "end": { + "byte": 4069, + "column": 65, + "line": 107 + }, + "start": { + "byte": 3580, + "column": 4, + "line": 100 + } + }, + "start_line": 100 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_audit_creates_one_skill_and_routes_adjacent_patterns", + "identity": "ActionCalibrationSkillTest.test_audit_creates_one_skill_and_routes_adjacent_patterns", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_cases_cover_minimal_maximal_prerequisite_and_nontrigger/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ActionCalibrationSkillTest.test_cases_cover_minimal_maximal_prerequisite_and_nontrigger", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::method:ActionCalibrationSkillTest.test_cases_cover_minimal_maximal_prerequisite_and_nontrigger", + "decorators": [], + "kind": "method", + "name": "test_cases_cover_minimal_maximal_prerequisite_and_nontrigger", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::class:ActionCalibrationSkillTest", + "qualified_name": "ActionCalibrationSkillTest.test_cases_cover_minimal_maximal_prerequisite_and_nontrigger", + "signature": "def test_cases_cover_minimal_maximal_prerequisite_and_nontrigger(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 116, + "span": { + "end": { + "byte": 4533, + "column": 78, + "line": 116 + }, + "start": { + "byte": 4075, + "column": 4, + "line": 109 + } + }, + "start_line": 109 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_cases_cover_minimal_maximal_prerequisite_and_nontrigger", + "identity": "ActionCalibrationSkillTest.test_cases_cover_minimal_maximal_prerequisite_and_nontrigger", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_codex_adapter_points_to_canonical_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ActionCalibrationSkillTest.test_codex_adapter_points_to_canonical_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::method:ActionCalibrationSkillTest.test_codex_adapter_points_to_canonical_skill", + "decorators": [], + "kind": "method", + "name": "test_codex_adapter_points_to_canonical_skill", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::class:ActionCalibrationSkillTest", + "qualified_name": "ActionCalibrationSkillTest.test_codex_adapter_points_to_canonical_skill", + "signature": "def test_codex_adapter_points_to_canonical_skill(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 121, + "span": { + "end": { + "byte": 4797, + "column": 64, + "line": 121 + }, + "start": { + "byte": 4539, + "column": 4, + "line": 118 + } + }, + "start_line": 118 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_codex_adapter_points_to_canonical_skill", + "identity": "ActionCalibrationSkillTest.test_codex_adapter_points_to_canonical_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_complete_cost_vector_is_preserved/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ActionCalibrationSkillTest.test_complete_cost_vector_is_preserved", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::method:ActionCalibrationSkillTest.test_complete_cost_vector_is_preserved", + "decorators": [], + "kind": "method", + "name": "test_complete_cost_vector_is_preserved", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::class:ActionCalibrationSkillTest", + "qualified_name": "ActionCalibrationSkillTest.test_complete_cost_vector_is_preserved", + "signature": "def test_complete_cost_vector_is_preserved(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 72, + "span": { + "end": { + "byte": 2611, + "column": 42, + "line": 72 + }, + "start": { + "byte": 2317, + "column": 4, + "line": 63 + } + }, + "start_line": 63 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_complete_cost_vector_is_preserved", + "identity": "ActionCalibrationSkillTest.test_complete_cost_vector_is_preserved", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_existing_skill_boundaries_are_explicit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ActionCalibrationSkillTest.test_existing_skill_boundaries_are_explicit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::method:ActionCalibrationSkillTest.test_existing_skill_boundaries_are_explicit", + "decorators": [], + "kind": "method", + "name": "test_existing_skill_boundaries_are_explicit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::class:ActionCalibrationSkillTest", + "qualified_name": "ActionCalibrationSkillTest.test_existing_skill_boundaries_are_explicit", + "signature": "def test_existing_skill_boundaries_are_explicit(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 87, + "span": { + "end": { + "byte": 3101, + "column": 47, + "line": 87 + }, + "start": { + "byte": 2617, + "column": 4, + "line": 74 + } + }, + "start_line": 74 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_existing_skill_boundaries_are_explicit", + "identity": "ActionCalibrationSkillTest.test_existing_skill_boundaries_are_explicit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_minimal_and_maximal_are_not_flattened/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ActionCalibrationSkillTest.test_minimal_and_maximal_are_not_flattened", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::method:ActionCalibrationSkillTest.test_minimal_and_maximal_are_not_flattened", + "decorators": [], + "kind": "method", + "name": "test_minimal_and_maximal_are_not_flattened", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::class:ActionCalibrationSkillTest", + "qualified_name": "ActionCalibrationSkillTest.test_minimal_and_maximal_are_not_flattened", + "signature": "def test_minimal_and_maximal_are_not_flattened(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 49, + "span": { + "end": { + "byte": 1875, + "column": 49, + "line": 49 + }, + "start": { + "byte": 1457, + "column": 4, + "line": 40 + } + }, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_minimal_and_maximal_are_not_flattened", + "identity": "ActionCalibrationSkillTest.test_minimal_and_maximal_are_not_flattened", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_thread_criteria_preserve_negative_and_control_results/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ActionCalibrationSkillTest.test_thread_criteria_preserve_negative_and_control_results", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::method:ActionCalibrationSkillTest.test_thread_criteria_preserve_negative_and_control_results", + "decorators": [], + "kind": "method", + "name": "test_thread_criteria_preserve_negative_and_control_results", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::class:ActionCalibrationSkillTest", + "qualified_name": "ActionCalibrationSkillTest.test_thread_criteria_preserve_negative_and_control_results", + "signature": "def test_thread_criteria_preserve_negative_and_control_results(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 98, + "span": { + "end": { + "byte": 3574, + "column": 52, + "line": 98 + }, + "start": { + "byte": 3107, + "column": 4, + "line": 89 + } + }, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_thread_criteria_preserve_negative_and_control_results", + "identity": "ActionCalibrationSkillTest.test_thread_criteria_preserve_negative_and_control_results", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_three_outcome_branches_and_stop_conditions_are_required/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ActionCalibrationSkillTest.test_three_outcome_branches_and_stop_conditions_are_required", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::method:ActionCalibrationSkillTest.test_three_outcome_branches_and_stop_conditions_are_required", + "decorators": [], + "kind": "method", + "name": "test_three_outcome_branches_and_stop_conditions_are_required", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::class:ActionCalibrationSkillTest", + "qualified_name": "ActionCalibrationSkillTest.test_three_outcome_branches_and_stop_conditions_are_required", + "signature": "def test_three_outcome_branches_and_stop_conditions_are_required(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 61, + "span": { + "end": { + "byte": 2311, + "column": 50, + "line": 61 + }, + "start": { + "byte": 1881, + "column": 4, + "line": 51 + } + }, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest.test_three_outcome_branches_and_stop_conditions_are_required", + "identity": "ActionCalibrationSkillTest.test_three_outcome_branches_and_stop_conditions_are_required", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "ActionCalibrationSkillTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_action_calibration_skill.py::class:ActionCalibrationSkillTest", + "decorators": [], + "kind": "class", + "name": "ActionCalibrationSkillTest", + "parent_identity": null, + "qualified_name": "ActionCalibrationSkillTest", + "signature": "class ActionCalibrationSkillTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "100b32d8e71bf822b86d5955218b027dd3e0aaf7ad5c8bb319fd42457de7bb4b", + "file": "tests/test_action_calibration_skill.py", + "location": { + "end_line": 121, + "span": { + "end": { + "byte": 4797, + "column": 64, + "line": 121 + }, + "start": { + "byte": 515, + "column": 0, + "line": 18 + } + }, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_action_calibration_skill.py#subject/symbol/ActionCalibrationSkillTest", + "identity": "ActionCalibrationSkillTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py", + "identity": "tests/test_ai_launcher.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py", + "identity": "tests/test_ai_launcher.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py", + "identity": "tests/test_ai_launcher.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/module/tests%2Ftest_ai_launcher.py", + "identity": "tests/test_ai_launcher.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_expected_vm_window_layout_and_commands_are_pinned/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "AILauncherTests.test_expected_vm_window_layout_and_commands_are_pinned", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::method:AILauncherTests.test_expected_vm_window_layout_and_commands_are_pinned", + "decorators": [], + "kind": "method", + "name": "test_expected_vm_window_layout_and_commands_are_pinned", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::class:AILauncherTests", + "qualified_name": "AILauncherTests.test_expected_vm_window_layout_and_commands_are_pinned", + "signature": "def test_expected_vm_window_layout_and_commands_are_pinned(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 52, + "span": { + "end": { + "byte": 1868, + "column": 39, + "line": 52 + }, + "start": { + "byte": 1336, + "column": 4, + "line": 41 + } + }, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_expected_vm_window_layout_and_commands_are_pinned", + "identity": "AILauncherTests.test_expected_vm_window_layout_and_commands_are_pinned", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_installer_places_ai_sh_on_termux_path_without_copying/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "AILauncherTests.test_installer_places_ai_sh_on_termux_path_without_copying", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::method:AILauncherTests.test_installer_places_ai_sh_on_termux_path_without_copying", + "decorators": [], + "kind": "method", + "name": "test_installer_places_ai_sh_on_termux_path_without_copying", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::class:AILauncherTests", + "qualified_name": "AILauncherTests.test_installer_places_ai_sh_on_termux_path_without_copying", + "signature": "def test_installer_places_ai_sh_on_termux_path_without_copying(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 86, + "span": { + "end": { + "byte": 3196, + "column": 56, + "line": 86 + }, + "start": { + "byte": 2746, + "column": 4, + "line": 76 + } + }, + "start_line": 76 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_installer_places_ai_sh_on_termux_path_without_copying", + "identity": "AILauncherTests.test_installer_places_ai_sh_on_termux_path_without_copying", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_keys_only_propagate_existing_vm_environment_into_tmux/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "AILauncherTests.test_keys_only_propagate_existing_vm_environment_into_tmux", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::method:AILauncherTests.test_keys_only_propagate_existing_vm_environment_into_tmux", + "decorators": [], + "kind": "method", + "name": "test_keys_only_propagate_existing_vm_environment_into_tmux", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::class:AILauncherTests", + "qualified_name": "AILauncherTests.test_keys_only_propagate_existing_vm_environment_into_tmux", + "signature": "def test_keys_only_propagate_existing_vm_environment_into_tmux(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 74, + "span": { + "end": { + "byte": 2740, + "column": 38, + "line": 74 + }, + "start": { + "byte": 2227, + "column": 4, + "line": 60 + } + }, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_keys_only_propagate_existing_vm_environment_into_tmux", + "identity": "AILauncherTests.test_keys_only_propagate_existing_vm_environment_into_tmux", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_launcher_is_termux_side_remote_tmux_controller/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "AILauncherTests.test_launcher_is_termux_side_remote_tmux_controller", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::method:AILauncherTests.test_launcher_is_termux_side_remote_tmux_controller", + "decorators": [], + "kind": "method", + "name": "test_launcher_is_termux_side_remote_tmux_controller", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::class:AILauncherTests", + "qualified_name": "AILauncherTests.test_launcher_is_termux_side_remote_tmux_controller", + "signature": "def test_launcher_is_termux_side_remote_tmux_controller(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 39, + "span": { + "end": { + "byte": 1330, + "column": 39, + "line": 39 + }, + "start": { + "byte": 787, + "column": 4, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_launcher_is_termux_side_remote_tmux_controller", + "identity": "AILauncherTests.test_launcher_is_termux_side_remote_tmux_controller", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_launcher_keeps_ratio_seals_as_literal_boundaries/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "AILauncherTests.test_launcher_keeps_ratio_seals_as_literal_boundaries", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::method:AILauncherTests.test_launcher_keeps_ratio_seals_as_literal_boundaries", + "decorators": [], + "kind": "method", + "name": "test_launcher_keeps_ratio_seals_as_literal_boundaries", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::class:AILauncherTests", + "qualified_name": "AILauncherTests.test_launcher_keeps_ratio_seals_as_literal_boundaries", + "signature": "def test_launcher_keeps_ratio_seals_as_literal_boundaries(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 23, + "span": { + "end": { + "byte": 781, + "column": 51, + "line": 23 + }, + "start": { + "byte": 506, + "column": 4, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_launcher_keeps_ratio_seals_as_literal_boundaries", + "identity": "AILauncherTests.test_launcher_keeps_ratio_seals_as_literal_boundaries", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_shell_syntax/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "AILauncherTests.test_shell_syntax", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::method:AILauncherTests.test_shell_syntax", + "decorators": [], + "kind": "method", + "name": "test_shell_syntax", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::class:AILauncherTests", + "qualified_name": "AILauncherTests.test_shell_syntax", + "signature": "def test_shell_syntax(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 17, + "span": { + "end": { + "byte": 500, + "column": 67, + "line": 17 + }, + "start": { + "byte": 351, + "column": 4, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_shell_syntax", + "identity": "AILauncherTests.test_shell_syntax", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_start_repairs_missing_or_dead_agents_without_restarting_healthy_ones/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "AILauncherTests.test_start_repairs_missing_or_dead_agents_without_restarting_healthy_ones", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::method:AILauncherTests.test_start_repairs_missing_or_dead_agents_without_restarting_healthy_ones", + "decorators": [], + "kind": "method", + "name": "test_start_repairs_missing_or_dead_agents_without_restarting_healthy_ones", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::class:AILauncherTests", + "qualified_name": "AILauncherTests.test_start_repairs_missing_or_dead_agents_without_restarting_healthy_ones", + "signature": "def test_start_repairs_missing_or_dead_agents_without_restarting_healthy_ones(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 58, + "span": { + "end": { + "byte": 2221, + "column": 62, + "line": 58 + }, + "start": { + "byte": 1874, + "column": 4, + "line": 54 + } + }, + "start_line": 54 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests.test_start_repairs_missing_or_dead_agents_without_restarting_healthy_ones", + "identity": "AILauncherTests.test_start_repairs_missing_or_dead_agents_without_restarting_healthy_ones", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "AILauncherTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ai_launcher.py::class:AILauncherTests", + "decorators": [], + "kind": "class", + "name": "AILauncherTests", + "parent_identity": null, + "qualified_name": "AILauncherTests", + "signature": "class AILauncherTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1fa1addc8e8d11afbb7485260ba075657d44dc88a17f42f5781cedb2dd6c7fbe", + "file": "tests/test_ai_launcher.py", + "location": { + "end_line": 86, + "span": { + "end": { + "byte": 3196, + "column": 56, + "line": 86 + }, + "start": { + "byte": 305, + "column": 0, + "line": 14 + } + }, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ai_launcher.py#subject/symbol/AILauncherTests", + "identity": "AILauncherTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "93:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A170-170/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "93:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 170, + "start_line": 170 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "6:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A170-170/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "6:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 170, + "start_line": 170 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "149:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A170-170/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "149:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 170, + "start_line": 170 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=149:1 imports_exports=6:1 calls_definitions=93:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 72, + "column": 72, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "identity": "tests/test_annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::<module>", + "metadata_kind": "comment", + "text": "noqa: E402" + } + }, + "origin": "native", + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 14, + "span": { + "end": { + "byte": 389, + "column": 40, + "line": 14 + }, + "start": { + "byte": 377, + "column": 28, + "line": 14 + } + }, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "identity": "tests/test_annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=149:1 imports_exports=6:1 calls_definitions=93:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 170, + "span": { + "end": { + "byte": 7419, + "column": 72, + "line": 170 + }, + "start": { + "byte": 7347, + "column": 0, + "line": 170 + } + }, + "start_line": 170 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "identity": "tests/test_annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Tests for the portable canonical-seal computer (ratios/annotate_index.py).", + "text": "Tests for the portable canonical-seal computer (ratios/annotate_index.py)." + } + }, + "origin": "native", + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 2, + "span": { + "end": { + "byte": 153, + "column": 80, + "line": 2 + }, + "start": { + "byte": 73, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "identity": "tests/test_annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "identity": "tests/test_annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "identity": "tests/test_annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "identity": "tests/test_annotate_index.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "identity": "tests/test_annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "identity": "tests/test_annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "annotate_index:annotate_index:5", + "value": { + "alias": "A", + "kind": "import", + "level": 0, + "module": "annotate_index", + "name": "annotate_index" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/module/tests%2Ftest_annotate_index.py", + "identity": "tests/test_annotate_index.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest._tree/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "BuildIndexTest._tree", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::method:BuildIndexTest._tree", + "decorators": [], + "kind": "method", + "name": "_tree", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::class:BuildIndexTest", + "qualified_name": "BuildIndexTest._tree", + "signature": "def _tree(self, td: Path) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 38, + "span": { + "end": { + "byte": 1219, + "column": 9, + "line": 38 + }, + "start": { + "byte": 437, + "column": 4, + "line": 18 + } + }, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest._tree", + "identity": "BuildIndexTest._tree", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_check_rejects_a_stale_closing_seal/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "BuildIndexTest.test_check_rejects_a_stale_closing_seal", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::method:BuildIndexTest.test_check_rejects_a_stale_closing_seal", + "decorators": [], + "kind": "method", + "name": "test_check_rejects_a_stale_closing_seal", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::class:BuildIndexTest", + "qualified_name": "BuildIndexTest.test_check_rejects_a_stale_closing_seal", + "signature": "def test_check_rejects_a_stale_closing_seal(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 165, + "span": { + "end": { + "byte": 7297, + "column": 71, + "line": 165 + }, + "start": { + "byte": 6743, + "column": 4, + "line": 156 + } + }, + "start_line": 156 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_check_rejects_a_stale_closing_seal", + "identity": "BuildIndexTest.test_check_rejects_a_stale_closing_seal", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_import_graph_exposes_the_same_relative_import_evidence/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "BuildIndexTest.test_import_graph_exposes_the_same_relative_import_evidence", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::method:BuildIndexTest.test_import_graph_exposes_the_same_relative_import_evidence", + "decorators": [], + "kind": "method", + "name": "test_import_graph_exposes_the_same_relative_import_evidence", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::class:BuildIndexTest", + "qualified_name": "BuildIndexTest.test_import_graph_exposes_the_same_relative_import_evidence", + "signature": "def test_import_graph_exposes_the_same_relative_import_evidence(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 66, + "span": { + "end": { + "byte": 2438, + "column": 52, + "line": 66 + }, + "start": { + "byte": 1907, + "column": 4, + "line": 56 + } + }, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_import_graph_exposes_the_same_relative_import_evidence", + "identity": "BuildIndexTest.test_import_graph_exposes_the_same_relative_import_evidence", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_metrics/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "BuildIndexTest.test_metrics", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::method:BuildIndexTest.test_metrics", + "decorators": [], + "kind": "method", + "name": "test_metrics", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::class:BuildIndexTest", + "qualified_name": "BuildIndexTest.test_metrics", + "signature": "def test_metrics(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 54, + "span": { + "end": { + "byte": 1901, + "column": 50, + "line": 54 + }, + "start": { + "byte": 1225, + "column": 4, + "line": 40 + } + }, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_metrics", + "identity": "BuildIndexTest.test_metrics", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_named_seals_self_exclude_without_becoming_compact_seals/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "BuildIndexTest.test_named_seals_self_exclude_without_becoming_compact_seals", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::method:BuildIndexTest.test_named_seals_self_exclude_without_becoming_compact_seals", + "decorators": [], + "kind": "method", + "name": "test_named_seals_self_exclude_without_becoming_compact_seals", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::class:BuildIndexTest", + "qualified_name": "BuildIndexTest.test_named_seals_self_exclude_without_becoming_compact_seals", + "signature": "def test_named_seals_self_exclude_without_becoming_compact_seals(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 90, + "span": { + "end": { + "byte": 3628, + "column": 56, + "line": 90 + }, + "start": { + "byte": 2444, + "column": 4, + "line": 68 + } + }, + "start_line": 68 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_named_seals_self_exclude_without_becoming_compact_seals", + "identity": "BuildIndexTest.test_named_seals_self_exclude_without_becoming_compact_seals", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_pure_library_reads_zero_cd/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "BuildIndexTest.test_pure_library_reads_zero_cd", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::method:BuildIndexTest.test_pure_library_reads_zero_cd", + "decorators": [], + "kind": "method", + "name": "test_pure_library_reads_zero_cd", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::class:BuildIndexTest", + "qualified_name": "BuildIndexTest.test_pure_library_reads_zero_cd", + "signature": "def test_pure_library_reads_zero_cd(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 106, + "span": { + "end": { + "byte": 4314, + "column": 68, + "line": 106 + }, + "start": { + "byte": 3908, + "column": 4, + "line": 98 + } + }, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_pure_library_reads_zero_cd", + "identity": "BuildIndexTest.test_pure_library_reads_zero_cd", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_seal_line_format/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "BuildIndexTest.test_seal_line_format", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::method:BuildIndexTest.test_seal_line_format", + "decorators": [], + "kind": "method", + "name": "test_seal_line_format", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::class:BuildIndexTest", + "qualified_name": "BuildIndexTest.test_seal_line_format", + "signature": "def test_seal_line_format(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 96, + "span": { + "end": { + "byte": 3902, + "column": 64, + "line": 96 + }, + "start": { + "byte": 3634, + "column": 4, + "line": 92 + } + }, + "start_line": 92 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_seal_line_format", + "identity": "BuildIndexTest.test_seal_line_format", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_write_and_check_preserve_python_and_node_shebangs/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "BuildIndexTest.test_write_and_check_preserve_python_and_node_shebangs", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::method:BuildIndexTest.test_write_and_check_preserve_python_and_node_shebangs", + "decorators": [], + "kind": "method", + "name": "test_write_and_check_preserve_python_and_node_shebangs", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::class:BuildIndexTest", + "qualified_name": "BuildIndexTest.test_write_and_check_preserve_python_and_node_shebangs", + "signature": "def test_write_and_check_preserve_python_and_node_shebangs(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 5776, + "column": 57, + "line": 135 + }, + "start": { + "byte": 4854, + "column": 4, + "line": 119 + } + }, + "start_line": 119 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_write_and_check_preserve_python_and_node_shebangs", + "identity": "BuildIndexTest.test_write_and_check_preserve_python_and_node_shebangs", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_write_and_check_roundtrip/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "BuildIndexTest.test_write_and_check_roundtrip", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::method:BuildIndexTest.test_write_and_check_roundtrip", + "decorators": [], + "kind": "method", + "name": "test_write_and_check_roundtrip", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::class:BuildIndexTest", + "qualified_name": "BuildIndexTest.test_write_and_check_roundtrip", + "signature": "def test_write_and_check_roundtrip(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 117, + "span": { + "end": { + "byte": 4848, + "column": 64, + "line": 117 + }, + "start": { + "byte": 4320, + "column": 4, + "line": 108 + } + }, + "start_line": 108 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_write_and_check_roundtrip", + "identity": "BuildIndexTest.test_write_and_check_roundtrip", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_write_repairs_a_seal_that_displaced_the_shebang/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "BuildIndexTest.test_write_repairs_a_seal_that_displaced_the_shebang", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::method:BuildIndexTest.test_write_repairs_a_seal_that_displaced_the_shebang", + "decorators": [], + "kind": "method", + "name": "test_write_repairs_a_seal_that_displaced_the_shebang", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::class:BuildIndexTest", + "qualified_name": "BuildIndexTest.test_write_repairs_a_seal_that_displaced_the_shebang", + "signature": "def test_write_repairs_a_seal_that_displaced_the_shebang(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 154, + "span": { + "end": { + "byte": 6737, + "column": 49, + "line": 154 + }, + "start": { + "byte": 5782, + "column": 4, + "line": 137 + } + }, + "start_line": 137 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest.test_write_repairs_a_seal_that_displaced_the_shebang", + "identity": "BuildIndexTest.test_write_repairs_a_seal_that_displaced_the_shebang", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "BuildIndexTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_annotate_index.py::class:BuildIndexTest", + "decorators": [], + "kind": "class", + "name": "BuildIndexTest", + "parent_identity": null, + "qualified_name": "BuildIndexTest", + "signature": "class BuildIndexTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "aba0e0ea4983e5587bfb6219132733f09546e4ade94a34aa736320e683713e17", + "file": "tests/test_annotate_index.py", + "location": { + "end_line": 165, + "span": { + "end": { + "byte": 7297, + "column": 71, + "line": 165 + }, + "start": { + "byte": 392, + "column": 0, + "line": 17 + } + }, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_annotate_index.py#subject/symbol/BuildIndexTest", + "identity": "BuildIndexTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/module/tests%2Ftest_char_compress_authority.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_char_compress_authority.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Guard the local-notation boundary separately from preservation fixtures.", + "text": "Guard the local-notation boundary separately from preservation fixtures." + } + }, + "origin": "native", + "source": { + "content_sha256": "ae6185ea8ef67eef74995cf57ac9bd0aebdf3eff1447ae2bfb80f1d055a66c2f", + "file": "tests/test_char_compress_authority.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 78, + "column": 78, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/module/tests%2Ftest_char_compress_authority.py", + "identity": "tests/test_char_compress_authority.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/module/tests%2Ftest_char_compress_authority.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ae6185ea8ef67eef74995cf57ac9bd0aebdf3eff1447ae2bfb80f1d055a66c2f", + "file": "tests/test_char_compress_authority.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/module/tests%2Ftest_char_compress_authority.py", + "identity": "tests/test_char_compress_authority.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/module/tests%2Ftest_char_compress_authority.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ae6185ea8ef67eef74995cf57ac9bd0aebdf3eff1447ae2bfb80f1d055a66c2f", + "file": "tests/test_char_compress_authority.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/module/tests%2Ftest_char_compress_authority.py", + "identity": "tests/test_char_compress_authority.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/symbol/CharCompressAuthorityTests.test_local_notation_does_not_claim_current_geometry/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CharCompressAuthorityTests.test_local_notation_does_not_claim_current_geometry", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_char_compress_authority.py::method:CharCompressAuthorityTests.test_local_notation_does_not_claim_current_geometry", + "decorators": [], + "kind": "method", + "name": "test_local_notation_does_not_claim_current_geometry", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_char_compress_authority.py::class:CharCompressAuthorityTests", + "qualified_name": "CharCompressAuthorityTests.test_local_notation_does_not_claim_current_geometry", + "signature": "def test_local_notation_does_not_claim_current_geometry(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ae6185ea8ef67eef74995cf57ac9bd0aebdf3eff1447ae2bfb80f1d055a66c2f", + "file": "tests/test_char_compress_authority.py", + "location": { + "end_line": 20, + "span": { + "end": { + "byte": 1124, + "column": 50, + "line": 20 + }, + "start": { + "byte": 223, + "column": 4, + "line": 9 + } + }, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/symbol/CharCompressAuthorityTests.test_local_notation_does_not_claim_current_geometry", + "identity": "CharCompressAuthorityTests.test_local_notation_does_not_claim_current_geometry", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/symbol/CharCompressAuthorityTests.test_optional_text_stack_is_not_a_required_completion_gate/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CharCompressAuthorityTests.test_optional_text_stack_is_not_a_required_completion_gate", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_char_compress_authority.py::method:CharCompressAuthorityTests.test_optional_text_stack_is_not_a_required_completion_gate", + "decorators": [], + "kind": "method", + "name": "test_optional_text_stack_is_not_a_required_completion_gate", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_char_compress_authority.py::class:CharCompressAuthorityTests", + "qualified_name": "CharCompressAuthorityTests.test_optional_text_stack_is_not_a_required_completion_gate", + "signature": "def test_optional_text_stack_is_not_a_required_completion_gate(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ae6185ea8ef67eef74995cf57ac9bd0aebdf3eff1447ae2bfb80f1d055a66c2f", + "file": "tests/test_char_compress_authority.py", + "location": { + "end_line": 36, + "span": { + "end": { + "byte": 2207, + "column": 96, + "line": 36 + }, + "start": { + "byte": 1487, + "column": 4, + "line": 28 + } + }, + "start_line": 28 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/symbol/CharCompressAuthorityTests.test_optional_text_stack_is_not_a_required_completion_gate", + "identity": "CharCompressAuthorityTests.test_optional_text_stack_is_not_a_required_completion_gate", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/symbol/CharCompressAuthorityTests.test_preservation_guards_survive_authority_correction/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CharCompressAuthorityTests.test_preservation_guards_survive_authority_correction", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_char_compress_authority.py::method:CharCompressAuthorityTests.test_preservation_guards_survive_authority_correction", + "decorators": [], + "kind": "method", + "name": "test_preservation_guards_survive_authority_correction", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_char_compress_authority.py::class:CharCompressAuthorityTests", + "qualified_name": "CharCompressAuthorityTests.test_preservation_guards_survive_authority_correction", + "signature": "def test_preservation_guards_survive_authority_correction(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ae6185ea8ef67eef74995cf57ac9bd0aebdf3eff1447ae2bfb80f1d055a66c2f", + "file": "tests/test_char_compress_authority.py", + "location": { + "end_line": 26, + "span": { + "end": { + "byte": 1481, + "column": 38, + "line": 26 + }, + "start": { + "byte": 1130, + "column": 4, + "line": 22 + } + }, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/symbol/CharCompressAuthorityTests.test_preservation_guards_survive_authority_correction", + "identity": "CharCompressAuthorityTests.test_preservation_guards_survive_authority_correction", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/symbol/CharCompressAuthorityTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "CharCompressAuthorityTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_char_compress_authority.py::class:CharCompressAuthorityTests", + "decorators": [], + "kind": "class", + "name": "CharCompressAuthorityTests", + "parent_identity": null, + "qualified_name": "CharCompressAuthorityTests", + "signature": "class CharCompressAuthorityTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ae6185ea8ef67eef74995cf57ac9bd0aebdf3eff1447ae2bfb80f1d055a66c2f", + "file": "tests/test_char_compress_authority.py", + "location": { + "end_line": 36, + "span": { + "end": { + "byte": 2207, + "column": 96, + "line": 36 + }, + "start": { + "byte": 166, + "column": 0, + "line": 8 + } + }, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_char_compress_authority.py#subject/symbol/CharCompressAuthorityTests", + "identity": "CharCompressAuthorityTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "23:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A134-134/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "23:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 134, + "start_line": 134 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "5:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A134-134/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "5:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 134, + "start_line": 134 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "121:28" + } + }, + "origin": "native", + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A134-134/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "121:28" + } + }, + "origin": "native", + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 134, + "start_line": 134 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collect.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=121:28 imports_exports=5:1 calls_definitions=23:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 72, + "column": 72, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "identity": "tests/test_collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collect.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=121:28 imports_exports=5:1 calls_definitions=23:4" + } + }, + "origin": "native", + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 134, + "span": { + "end": { + "byte": 5047, + "column": 72, + "line": 134 + }, + "start": { + "byte": 4975, + "column": 0, + "line": 134 + } + }, + "start_line": 134 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "identity": "tests/test_collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "identity": "tests/test_collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "identity": "tests/test_collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "identity": "tests/test_collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "identity": "tests/test_collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:SCHEMA_VERSION:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "SCHEMA_VERSION" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "identity": "tests/test_collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collect:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collect" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "identity": "tests/test_collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collect_legacy:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collect_legacy" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "identity": "tests/test_collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:render_typescript:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "render_typescript" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/module/tests%2Ftest_collect.py", + "identity": "tests/test_collect.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/symbol/CollectTest.test_collect_emits_declarations_gaps_and_edges/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CollectTest.test_collect_emits_declarations_gaps_and_edges", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collect.py::method:CollectTest.test_collect_emits_declarations_gaps_and_edges", + "decorators": [], + "kind": "method", + "name": "test_collect_emits_declarations_gaps_and_edges", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_collect.py::class:CollectTest", + "qualified_name": "CollectTest.test_collect_emits_declarations_gaps_and_edges", + "signature": "def test_collect_emits_declarations_gaps_and_edges(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 75, + "span": { + "end": { + "byte": 2882, + "column": 91, + "line": 75 + }, + "start": { + "byte": 296, + "column": 4, + "line": 12 + } + }, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/symbol/CollectTest.test_collect_emits_declarations_gaps_and_edges", + "identity": "CollectTest.test_collect_emits_declarations_gaps_and_edges", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/symbol/CollectTest.test_collect_legacy_is_explicitly_block_only/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CollectTest.test_collect_legacy_is_explicitly_block_only", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collect.py::method:CollectTest.test_collect_legacy_is_explicitly_block_only", + "decorators": [], + "kind": "method", + "name": "test_collect_legacy_is_explicitly_block_only", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_collect.py::class:CollectTest", + "qualified_name": "CollectTest.test_collect_legacy_is_explicitly_block_only", + "signature": "def test_collect_legacy_is_explicitly_block_only(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 98, + "span": { + "end": { + "byte": 3995, + "column": 63, + "line": 98 + }, + "start": { + "byte": 3387, + "column": 4, + "line": 87 + } + }, + "start_line": 87 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/symbol/CollectTest.test_collect_legacy_is_explicitly_block_only", + "identity": "CollectTest.test_collect_legacy_is_explicitly_block_only", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/symbol/CollectTest.test_collect_skips_vendored_agent_skills/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CollectTest.test_collect_skips_vendored_agent_skills", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collect.py::method:CollectTest.test_collect_skips_vendored_agent_skills", + "decorators": [], + "kind": "method", + "name": "test_collect_skips_vendored_agent_skills", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_collect.py::class:CollectTest", + "qualified_name": "CollectTest.test_collect_skips_vendored_agent_skills", + "signature": "def test_collect_skips_vendored_agent_skills(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 129, + "span": { + "end": { + "byte": 4925, + "column": 13, + "line": 129 + }, + "start": { + "byte": 4001, + "column": 4, + "line": 100 + } + }, + "start_line": 100 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/symbol/CollectTest.test_collect_skips_vendored_agent_skills", + "identity": "CollectTest.test_collect_skips_vendored_agent_skills", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/symbol/CollectTest.test_render_typescript_uses_collection_helper/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CollectTest.test_render_typescript_uses_collection_helper", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collect.py::method:CollectTest.test_render_typescript_uses_collection_helper", + "decorators": [], + "kind": "method", + "name": "test_render_typescript_uses_collection_helper", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_collect.py::class:CollectTest", + "qualified_name": "CollectTest.test_render_typescript_uses_collection_helper", + "signature": "def test_render_typescript_uses_collection_helper(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 85, + "span": { + "end": { + "byte": 3381, + "column": 51, + "line": 85 + }, + "start": { + "byte": 2888, + "column": 4, + "line": 77 + } + }, + "start_line": 77 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/symbol/CollectTest.test_render_typescript_uses_collection_helper", + "identity": "CollectTest.test_render_typescript_uses_collection_helper", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/symbol/CollectTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "CollectTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collect.py::class:CollectTest", + "decorators": [], + "kind": "class", + "name": "CollectTest", + "parent_identity": null, + "qualified_name": "CollectTest", + "signature": "class CollectTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0cea645ddfb8590e48a1c1caa21bc8a69afb538ba86834c34ff052b09656a24c", + "file": "tests/test_collect.py", + "location": { + "end_line": 129, + "span": { + "end": { + "byte": 4925, + "column": 13, + "line": 129 + }, + "start": { + "byte": 254, + "column": 0, + "line": 11 + } + }, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collect.py#subject/symbol/CollectTest", + "identity": "CollectTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b9255106d56f874064ee7dbe182c8d16fd6d9bfea3dba4390a187d97a80b7b", + "file": "tests/test_collection_schema.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py", + "identity": "tests/test_collection_schema.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b9255106d56f874064ee7dbe182c8d16fd6d9bfea3dba4390a187d97a80b7b", + "file": "tests/test_collection_schema.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py", + "identity": "tests/test_collection_schema.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b9255106d56f874064ee7dbe182c8d16fd6d9bfea3dba4390a187d97a80b7b", + "file": "tests/test_collection_schema.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py", + "identity": "tests/test_collection_schema.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b9255106d56f874064ee7dbe182c8d16fd6d9bfea3dba4390a187d97a80b7b", + "file": "tests/test_collection_schema.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/module/tests%2Ftest_collection_schema.py", + "identity": "tests/test_collection_schema.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CollectionSchemaTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collection_schema.py::method:CollectionSchemaTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_collection_schema.py::class:CollectionSchemaTest", + "qualified_name": "CollectionSchemaTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b9255106d56f874064ee7dbe182c8d16fd6d9bfea3dba4390a187d97a80b7b", + "file": "tests/test_collection_schema.py", + "location": { + "end_line": 26, + "span": { + "end": { + "byte": 525, + "column": 63, + "line": 26 + }, + "start": { + "byte": 437, + "column": 4, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest.setUp", + "identity": "CollectionSchemaTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest.test_block_name_union_covers_registered_application_blocks/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CollectionSchemaTest.test_block_name_union_covers_registered_application_blocks", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collection_schema.py::method:CollectionSchemaTest.test_block_name_union_covers_registered_application_blocks", + "decorators": [], + "kind": "method", + "name": "test_block_name_union_covers_registered_application_blocks", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_collection_schema.py::class:CollectionSchemaTest", + "qualified_name": "CollectionSchemaTest.test_block_name_union_covers_registered_application_blocks", + "signature": "def test_block_name_union_covers_registered_application_blocks(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b9255106d56f874064ee7dbe182c8d16fd6d9bfea3dba4390a187d97a80b7b", + "file": "tests/test_collection_schema.py", + "location": { + "end_line": 49, + "span": { + "end": { + "byte": 1383, + "column": 58, + "line": 49 + }, + "start": { + "byte": 1173, + "column": 4, + "line": 47 + } + }, + "start_line": 47 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest.test_block_name_union_covers_registered_application_blocks", + "identity": "CollectionSchemaTest.test_block_name_union_covers_registered_application_blocks", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest.test_collection_schema_exports_required_types/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CollectionSchemaTest.test_collection_schema_exports_required_types", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collection_schema.py::method:CollectionSchemaTest.test_collection_schema_exports_required_types", + "decorators": [], + "kind": "method", + "name": "test_collection_schema_exports_required_types", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_collection_schema.py::class:CollectionSchemaTest", + "qualified_name": "CollectionSchemaTest.test_collection_schema_exports_required_types", + "signature": "def test_collection_schema_exports_required_types(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b9255106d56f874064ee7dbe182c8d16fd6d9bfea3dba4390a187d97a80b7b", + "file": "tests/test_collection_schema.py", + "location": { + "end_line": 45, + "span": { + "end": { + "byte": 1167, + "column": 52, + "line": 45 + }, + "start": { + "byte": 531, + "column": 4, + "line": 28 + } + }, + "start_line": 28 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest.test_collection_schema_exports_required_types", + "identity": "CollectionSchemaTest.test_collection_schema_exports_required_types", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest.test_declaration_gap_and_edge_shapes_have_visualizer_fields/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CollectionSchemaTest.test_declaration_gap_and_edge_shapes_have_visualizer_fields", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collection_schema.py::method:CollectionSchemaTest.test_declaration_gap_and_edge_shapes_have_visualizer_fields", + "decorators": [], + "kind": "method", + "name": "test_declaration_gap_and_edge_shapes_have_visualizer_fields", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_collection_schema.py::class:CollectionSchemaTest", + "qualified_name": "CollectionSchemaTest.test_declaration_gap_and_edge_shapes_have_visualizer_fields", + "signature": "def test_declaration_gap_and_edge_shapes_have_visualizer_fields(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b9255106d56f874064ee7dbe182c8d16fd6d9bfea3dba4390a187d97a80b7b", + "file": "tests/test_collection_schema.py", + "location": { + "end_line": 66, + "span": { + "end": { + "byte": 1960, + "column": 49, + "line": 66 + }, + "start": { + "byte": 1389, + "column": 4, + "line": 51 + } + }, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest.test_declaration_gap_and_edge_shapes_have_visualizer_fields", + "identity": "CollectionSchemaTest.test_declaration_gap_and_edge_shapes_have_visualizer_fields", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest.test_native_schema_requires_version_provenance_and_negotiation/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "CollectionSchemaTest.test_native_schema_requires_version_provenance_and_negotiation", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collection_schema.py::method:CollectionSchemaTest.test_native_schema_requires_version_provenance_and_negotiation", + "decorators": [], + "kind": "method", + "name": "test_native_schema_requires_version_provenance_and_negotiation", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_collection_schema.py::class:CollectionSchemaTest", + "qualified_name": "CollectionSchemaTest.test_native_schema_requires_version_provenance_and_negotiation", + "signature": "def test_native_schema_requires_version_provenance_and_negotiation(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b9255106d56f874064ee7dbe182c8d16fd6d9bfea3dba4390a187d97a80b7b", + "file": "tests/test_collection_schema.py", + "location": { + "end_line": 83, + "span": { + "end": { + "byte": 2632, + "column": 49, + "line": 83 + }, + "start": { + "byte": 1966, + "column": 4, + "line": 68 + } + }, + "start_line": 68 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest.test_native_schema_requires_version_provenance_and_negotiation", + "identity": "CollectionSchemaTest.test_native_schema_requires_version_provenance_and_negotiation", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "CollectionSchemaTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_collection_schema.py::class:CollectionSchemaTest", + "decorators": [], + "kind": "class", + "name": "CollectionSchemaTest", + "parent_identity": null, + "qualified_name": "CollectionSchemaTest", + "signature": "class CollectionSchemaTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b9255106d56f874064ee7dbe182c8d16fd6d9bfea3dba4390a187d97a80b7b", + "file": "tests/test_collection_schema.py", + "location": { + "end_line": 83, + "span": { + "end": { + "byte": 2632, + "column": 49, + "line": 83 + }, + "start": { + "byte": 386, + "column": 0, + "line": 24 + } + }, + "start_line": 24 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_collection_schema.py#subject/symbol/CollectionSchemaTest", + "identity": "CollectionSchemaTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::<module>", + "metadata_kind": "comment", + "text": "dataclass introspection needs the module registered" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 15, + "span": { + "end": { + "byte": 435, + "column": 84, + "line": 15 + }, + "start": { + "byte": 382, + "column": 31, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "identity": "tests/test_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "identity": "tests/test_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "identity": "tests/test_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "importlib.util:importlib.util:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "importlib.util", + "name": "importlib.util" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "identity": "tests/test_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "identity": "tests/test_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "identity": "tests/test_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "identity": "tests/test_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/module/tests%2Ftest_consumer_drift.py", + "identity": "tests/test_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest._manifest_with_pin/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest._manifest_with_pin", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest._manifest_with_pin", + "decorators": [], + "kind": "method", + "name": "_manifest_with_pin", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest._manifest_with_pin", + "signature": "def _manifest_with_pin(self, pin_text: str) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 113, + "span": { + "end": { + "byte": 5111, + "column": 94, + "line": 113 + }, + "start": { + "byte": 4670, + "column": 4, + "line": 108 + } + }, + "start_line": 108 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest._manifest_with_pin", + "identity": "ConsumerDriftTest._manifest_with_pin", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest._reference_doctrine/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest._reference_doctrine", + "metadata_kind": "comment", + "text": "canonical msdmd links to a shared doctrine doc; keep the vendored SKILL.md\nidentical so only doctrine state varies." + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 215, + "span": { + "end": { + "byte": 10283, + "column": 50, + "line": 215 + }, + "start": { + "byte": 10156, + "column": 8, + "line": 214 + } + }, + "start_line": 214 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest._reference_doctrine", + "identity": "ConsumerDriftTest._reference_doctrine", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest._reference_doctrine/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest._reference_doctrine", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest._reference_doctrine", + "decorators": [], + "kind": "method", + "name": "_reference_doctrine", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest._reference_doctrine", + "signature": "def _reference_doctrine(self, in_consumer: bool=True, consumer_body: str='DOCTRINE\\n') -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 221, + "span": { + "end": { + "byte": 10693, + "column": 100, + "line": 221 + }, + "start": { + "byte": 10048, + "column": 4, + "line": 213 + } + }, + "start_line": 213 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest._reference_doctrine", + "identity": "ConsumerDriftTest._reference_doctrine", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest._report/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest._report", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest._report", + "decorators": [], + "kind": "method", + "name": "_report", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest._report", + "signature": "def _report(self, **kw)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 50, + "span": { + "end": { + "byte": 1783, + "column": 77, + "line": 50 + }, + "start": { + "byte": 1681, + "column": 4, + "line": 49 + } + }, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest._report", + "identity": "ConsumerDriftTest._report", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.setUp/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.setUp", + "metadata_kind": "comment", + "text": "canonical skill with a SKILL.md and a helper file" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 30, + "span": { + "end": { + "byte": 904, + "column": 59, + "line": 30 + }, + "start": { + "byte": 853, + "column": 8, + "line": 30 + } + }, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.setUp", + "identity": "ConsumerDriftTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.setUp/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.setUp", + "metadata_kind": "comment", + "text": "a second canonical skill the consumer does NOT vendor" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 33, + "span": { + "end": { + "byte": 1120, + "column": 63, + "line": 33 + }, + "start": { + "byte": 1065, + "column": 8, + "line": 33 + } + }, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.setUp", + "identity": "ConsumerDriftTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.setUp/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.setUp", + "metadata_kind": "comment", + "text": "consumer vendors msdmd verbatim" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 39, + "span": { + "end": { + "byte": 1383, + "column": 41, + "line": 39 + }, + "start": { + "byte": 1350, + "column": 8, + "line": 39 + } + }, + "start_line": 39 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.setUp", + "identity": "ConsumerDriftTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 44, + "span": { + "end": { + "byte": 1614, + "column": 9, + "line": 44 + }, + "start": { + "byte": 656, + "column": 4, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.setUp", + "identity": "ConsumerDriftTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.tearDown/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.tearDown", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.tearDown", + "decorators": [], + "kind": "method", + "name": "tearDown", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.tearDown", + "signature": "def tearDown(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 47, + "span": { + "end": { + "byte": 1675, + "column": 27, + "line": 47 + }, + "start": { + "byte": 1620, + "column": 4, + "line": 46 + } + }, + "start_line": 46 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.tearDown", + "identity": "ConsumerDriftTest.tearDown", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_differing_file_is_drift/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_differing_file_is_drift", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_differing_file_is_drift", + "decorators": [], + "kind": "method", + "name": "test_differing_file_is_drift", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_differing_file_is_drift", + "signature": "def test_differing_file_is_drift(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 67, + "span": { + "end": { + "byte": 2589, + "column": 75, + "line": 67 + }, + "start": { + "byte": 2245, + "column": 4, + "line": 62 + } + }, + "start_line": 62 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_differing_file_is_drift", + "identity": "ConsumerDriftTest.test_differing_file_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_format_and_exit_code/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_format_and_exit_code", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_format_and_exit_code", + "decorators": [], + "kind": "method", + "name": "test_format_and_exit_code", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_format_and_exit_code", + "signature": "def test_format_and_exit_code(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 250, + "span": { + "end": { + "byte": 12033, + "column": 31, + "line": 250 + }, + "start": { + "byte": 11771, + "column": 4, + "line": 246 + } + }, + "start_line": 246 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_format_and_exit_code", + "identity": "ConsumerDriftTest.test_format_and_exit_code", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_local_addition_is_ignored/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_local_addition_is_ignored", + "metadata_kind": "comment", + "text": "a repo-local extra file must not count as drift" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 76, + "span": { + "end": { + "byte": 3021, + "column": 57, + "line": 76 + }, + "start": { + "byte": 2972, + "column": 8, + "line": 76 + } + }, + "start_line": 76 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_local_addition_is_ignored", + "identity": "ConsumerDriftTest.test_local_addition_is_ignored", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_local_addition_is_ignored/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_local_addition_is_ignored", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_local_addition_is_ignored", + "decorators": [], + "kind": "method", + "name": "test_local_addition_is_ignored", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_local_addition_is_ignored", + "signature": "def test_local_addition_is_ignored(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 79, + "span": { + "end": { + "byte": 3195, + "column": 57, + "line": 79 + }, + "start": { + "byte": 2914, + "column": 4, + "line": 75 + } + }, + "start_line": 75 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_local_addition_is_ignored", + "identity": "ConsumerDriftTest.test_local_addition_is_ignored", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_local_only_skill_is_ignored/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_local_only_skill_is_ignored", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_local_only_skill_is_ignored", + "decorators": [], + "kind": "method", + "name": "test_local_only_skill_is_ignored", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_local_only_skill_is_ignored", + "signature": "def test_local_only_skill_is_ignored(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 84, + "span": { + "end": { + "byte": 3444, + "column": 71, + "line": 84 + }, + "start": { + "byte": 3201, + "column": 4, + "line": 81 + } + }, + "start_line": 81 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_local_only_skill_is_ignored", + "identity": "ConsumerDriftTest.test_local_only_skill_is_ignored", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_binary_marker_is_clean/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_binary_marker_is_clean", + "metadata_kind": "comment", + "text": "sha256sum binary mode" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 131, + "span": { + "end": { + "byte": 6080, + "column": 84, + "line": 131 + }, + "start": { + "byte": 6057, + "column": 61, + "line": 131 + } + }, + "start_line": 131 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_binary_marker_is_clean", + "identity": "ConsumerDriftTest.test_manifest_pin_binary_marker_is_clean", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_binary_marker_is_clean/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_manifest_pin_binary_marker_is_clean", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_binary_marker_is_clean", + "decorators": [], + "kind": "method", + "name": "test_manifest_pin_binary_marker_is_clean", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_manifest_pin_binary_marker_is_clean", + "signature": "def test_manifest_pin_binary_marker_is_clean(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 134, + "span": { + "end": { + "byte": 6223, + "column": 36, + "line": 134 + }, + "start": { + "byte": 5882, + "column": 4, + "line": 129 + } + }, + "start_line": 129 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_binary_marker_is_clean", + "identity": "ConsumerDriftTest.test_manifest_pin_binary_marker_is_clean", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_current_is_clean/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_manifest_pin_current_is_clean", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_current_is_clean", + "decorators": [], + "kind": "method", + "name": "test_manifest_pin_current_is_clean", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_manifest_pin_current_is_clean", + "signature": "def test_manifest_pin_current_is_clean(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 175, + "span": { + "end": { + "byte": 8468, + "column": 36, + "line": 175 + }, + "start": { + "byte": 7776, + "column": 4, + "line": 163 + } + }, + "start_line": 163 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_current_is_clean", + "identity": "ConsumerDriftTest.test_manifest_pin_current_is_clean", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_double_marker_is_drift/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_double_marker_is_drift", + "metadata_kind": "comment", + "text": "'**generate.py' names the file '*generate.py' to sha256sum -c, not generate.py" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 137, + "span": { + "end": { + "byte": 6377, + "column": 88, + "line": 137 + }, + "start": { + "byte": 6297, + "column": 8, + "line": 137 + } + }, + "start_line": 137 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_double_marker_is_drift", + "identity": "ConsumerDriftTest.test_manifest_pin_double_marker_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_double_marker_is_drift/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_manifest_pin_double_marker_is_drift", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_double_marker_is_drift", + "decorators": [], + "kind": "method", + "name": "test_manifest_pin_double_marker_is_drift", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_manifest_pin_double_marker_is_drift", + "signature": "def test_manifest_pin_double_marker_is_drift(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 142, + "span": { + "end": { + "byte": 6673, + "column": 74, + "line": 142 + }, + "start": { + "byte": 6229, + "column": 4, + "line": 136 + } + }, + "start_line": 136 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_double_marker_is_drift", + "identity": "ConsumerDriftTest.test_manifest_pin_double_marker_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_extra_line_is_drift/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_manifest_pin_extra_line_is_drift", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_extra_line_is_drift", + "decorators": [], + "kind": "method", + "name": "test_manifest_pin_extra_line_is_drift", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_manifest_pin_extra_line_is_drift", + "signature": "def test_manifest_pin_extra_line_is_drift(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 127, + "span": { + "end": { + "byte": 5876, + "column": 74, + "line": 127 + }, + "start": { + "byte": 5505, + "column": 4, + "line": 122 + } + }, + "start_line": 122 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_extra_line_is_drift", + "identity": "ConsumerDriftTest.test_manifest_pin_extra_line_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_extra_separator_is_drift/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_extra_separator_is_drift", + "metadata_kind": "comment", + "text": "sha256sum -c allows exactly one space + one mode char; surplus spacing\nbecomes part of the filename, so these must not read clean." + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 146, + "span": { + "end": { + "byte": 6891, + "column": 69, + "line": 146 + }, + "start": { + "byte": 6749, + "column": 8, + "line": 145 + } + }, + "start_line": 145 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_extra_separator_is_drift", + "identity": "ConsumerDriftTest.test_manifest_pin_extra_separator_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_extra_separator_is_drift/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_manifest_pin_extra_separator_is_drift", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_extra_separator_is_drift", + "decorators": [], + "kind": "method", + "name": "test_manifest_pin_extra_separator_is_drift", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_manifest_pin_extra_separator_is_drift", + "signature": "def test_manifest_pin_extra_separator_is_drift(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 153, + "span": { + "end": { + "byte": 7314, + "column": 82, + "line": 153 + }, + "start": { + "byte": 6679, + "column": 4, + "line": 144 + } + }, + "start_line": 144 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_extra_separator_is_drift", + "identity": "ConsumerDriftTest.test_manifest_pin_extra_separator_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_stale_is_drift/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_stale_is_drift", + "metadata_kind": "comment", + "text": "valid format, wrong digest" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 99, + "span": { + "end": { + "byte": 4340, + "column": 86, + "line": 99 + }, + "start": { + "byte": 4312, + "column": 58, + "line": 99 + } + }, + "start_line": 99 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_stale_is_drift", + "identity": "ConsumerDriftTest.test_manifest_pin_stale_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_stale_is_drift/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_manifest_pin_stale_is_drift", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_stale_is_drift", + "decorators": [], + "kind": "method", + "name": "test_manifest_pin_stale_is_drift", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_manifest_pin_stale_is_drift", + "signature": "def test_manifest_pin_stale_is_drift(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 106, + "span": { + "end": { + "byte": 4664, + "column": 70, + "line": 106 + }, + "start": { + "byte": 3908, + "column": 4, + "line": 94 + } + }, + "start_line": 94 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_stale_is_drift", + "identity": "ConsumerDriftTest.test_manifest_pin_stale_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_uppercase_digest_is_drift/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_uppercase_digest_is_drift", + "metadata_kind": "comment", + "text": "GNU sha256sum emits lowercase hex; an uppercased digest is not its format." + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 156, + "span": { + "end": { + "byte": 7467, + "column": 84, + "line": 156 + }, + "start": { + "byte": 7391, + "column": 8, + "line": 156 + } + }, + "start_line": 156 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_uppercase_digest_is_drift", + "identity": "ConsumerDriftTest.test_manifest_pin_uppercase_digest_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_uppercase_digest_is_drift/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_manifest_pin_uppercase_digest_is_drift", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_uppercase_digest_is_drift", + "decorators": [], + "kind": "method", + "name": "test_manifest_pin_uppercase_digest_is_drift", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_manifest_pin_uppercase_digest_is_drift", + "signature": "def test_manifest_pin_uppercase_digest_is_drift(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 161, + "span": { + "end": { + "byte": 7770, + "column": 74, + "line": 161 + }, + "start": { + "byte": 7320, + "column": 4, + "line": 155 + } + }, + "start_line": 155 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_uppercase_digest_is_drift", + "identity": "ConsumerDriftTest.test_manifest_pin_uppercase_digest_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_wrong_filename_is_drift/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_wrong_filename_is_drift", + "metadata_kind": "comment", + "text": "correct digest, wrong name" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 117, + "span": { + "end": { + "byte": 5318, + "column": 86, + "line": 117 + }, + "start": { + "byte": 5290, + "column": 58, + "line": 117 + } + }, + "start_line": 117 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_wrong_filename_is_drift", + "identity": "ConsumerDriftTest.test_manifest_pin_wrong_filename_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_wrong_filename_is_drift/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_manifest_pin_wrong_filename_is_drift", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_manifest_pin_wrong_filename_is_drift", + "decorators": [], + "kind": "method", + "name": "test_manifest_pin_wrong_filename_is_drift", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_manifest_pin_wrong_filename_is_drift", + "signature": "def test_manifest_pin_wrong_filename_is_drift(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 120, + "span": { + "end": { + "byte": 5499, + "column": 74, + "line": 120 + }, + "start": { + "byte": 5117, + "column": 4, + "line": 115 + } + }, + "start_line": 115 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_manifest_pin_wrong_filename_is_drift", + "identity": "ConsumerDriftTest.test_manifest_pin_wrong_filename_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_missing_canonical_file_is_drift/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_missing_canonical_file_is_drift", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_missing_canonical_file_is_drift", + "decorators": [], + "kind": "method", + "name": "test_missing_canonical_file_is_drift", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_missing_canonical_file_is_drift", + "signature": "def test_missing_canonical_file_is_drift(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 73, + "span": { + "end": { + "byte": 2908, + "column": 66, + "line": 73 + }, + "start": { + "byte": 2595, + "column": 4, + "line": 69 + } + }, + "start_line": 69 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_missing_canonical_file_is_drift", + "identity": "ConsumerDriftTest.test_missing_canonical_file_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_missing_referenced_doctrine_is_drift/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_missing_referenced_doctrine_is_drift", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_missing_referenced_doctrine_is_drift", + "decorators": [], + "kind": "method", + "name": "test_missing_referenced_doctrine_is_drift", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_missing_referenced_doctrine_is_drift", + "signature": "def test_missing_referenced_doctrine_is_drift(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 233, + "span": { + "end": { + "byte": 11218, + "column": 31, + "line": 233 + }, + "start": { + "byte": 10878, + "column": 4, + "line": 228 + } + }, + "start_line": 228 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_missing_referenced_doctrine_is_drift", + "identity": "ConsumerDriftTest.test_missing_referenced_doctrine_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_no_require_vendored_empty_is_clean/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_no_require_vendored_empty_is_clean", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_no_require_vendored_empty_is_clean", + "decorators": [], + "kind": "method", + "name": "test_no_require_vendored_empty_is_clean", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_no_require_vendored_empty_is_clean", + "signature": "def test_no_require_vendored_empty_is_clean(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 211, + "span": { + "end": { + "byte": 10042, + "column": 32, + "line": 211 + }, + "start": { + "byte": 9723, + "column": 4, + "line": 206 + } + }, + "start_line": 206 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_no_require_vendored_empty_is_clean", + "identity": "ConsumerDriftTest.test_no_require_vendored_empty_is_clean", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_no_skills_dir_reports_nothing_vendored/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_no_skills_dir_reports_nothing_vendored", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_no_skills_dir_reports_nothing_vendored", + "decorators": [], + "kind": "method", + "name": "test_no_skills_dir_reports_nothing_vendored", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_no_skills_dir_reports_nothing_vendored", + "signature": "def test_no_skills_dir_reports_nothing_vendored(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 192, + "span": { + "end": { + "byte": 9160, + "column": 67, + "line": 192 + }, + "start": { + "byte": 8851, + "column": 4, + "line": 187 + } + }, + "start_line": 187 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_no_skills_dir_reports_nothing_vendored", + "identity": "ConsumerDriftTest.test_no_skills_dir_reports_nothing_vendored", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_only_vendored_intersection_is_checked/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_only_vendored_intersection_is_checked", + "metadata_kind": "comment", + "text": "doc-build exists canonically but is not vendored -> not reported" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 58, + "span": { + "end": { + "byte": 2136, + "column": 74, + "line": 58 + }, + "start": { + "byte": 2070, + "column": 8, + "line": 58 + } + }, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_only_vendored_intersection_is_checked", + "identity": "ConsumerDriftTest.test_only_vendored_intersection_is_checked", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_only_vendored_intersection_is_checked/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_only_vendored_intersection_is_checked", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_only_vendored_intersection_is_checked", + "decorators": [], + "kind": "method", + "name": "test_only_vendored_intersection_is_checked", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_only_vendored_intersection_is_checked", + "signature": "def test_only_vendored_intersection_is_checked(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 60, + "span": { + "end": { + "byte": 2239, + "column": 70, + "line": 60 + }, + "start": { + "byte": 2000, + "column": 4, + "line": 57 + } + }, + "start_line": 57 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_only_vendored_intersection_is_checked", + "identity": "ConsumerDriftTest.test_only_vendored_intersection_is_checked", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_referenced_doctrine_present_is_clean/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_referenced_doctrine_present_is_clean", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_referenced_doctrine_present_is_clean", + "decorators": [], + "kind": "method", + "name": "test_referenced_doctrine_present_is_clean", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_referenced_doctrine_present_is_clean", + "signature": "def test_referenced_doctrine_present_is_clean(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 226, + "span": { + "end": { + "byte": 10872, + "column": 45, + "line": 226 + }, + "start": { + "byte": 10699, + "column": 4, + "line": 223 + } + }, + "start_line": 223 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_referenced_doctrine_present_is_clean", + "identity": "ConsumerDriftTest.test_referenced_doctrine_present_is_clean", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_require_vendored_empty_fails/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_require_vendored_empty_fails", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_require_vendored_empty_fails", + "decorators": [], + "kind": "method", + "name": "test_require_vendored_empty_fails", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_require_vendored_empty_fails", + "signature": "def test_require_vendored_empty_fails(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 199, + "span": { + "end": { + "byte": 9477, + "column": 31, + "line": 199 + }, + "start": { + "byte": 9166, + "column": 4, + "line": 194 + } + }, + "start_line": 194 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_require_vendored_empty_fails", + "identity": "ConsumerDriftTest.test_require_vendored_empty_fails", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_require_vendored_with_subset_is_clean/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_require_vendored_with_subset_is_clean", + "metadata_kind": "comment", + "text": "vendors msdmd" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 202, + "span": { + "end": { + "byte": 9593, + "column": 48, + "line": 202 + }, + "start": { + "byte": 9578, + "column": 33, + "line": 202 + } + }, + "start_line": 202 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_require_vendored_with_subset_is_clean", + "identity": "ConsumerDriftTest.test_require_vendored_with_subset_is_clean", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_require_vendored_with_subset_is_clean/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_require_vendored_with_subset_is_clean", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_require_vendored_with_subset_is_clean", + "decorators": [], + "kind": "method", + "name": "test_require_vendored_with_subset_is_clean", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_require_vendored_with_subset_is_clean", + "signature": "def test_require_vendored_with_subset_is_clean(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 204, + "span": { + "end": { + "byte": 9717, + "column": 32, + "line": 204 + }, + "start": { + "byte": 9483, + "column": 4, + "line": 201 + } + }, + "start_line": 201 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_require_vendored_with_subset_is_clean", + "identity": "ConsumerDriftTest.test_require_vendored_with_subset_is_clean", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_sha_citation_warning/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_sha_citation_warning", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_sha_citation_warning", + "decorators": [], + "kind": "method", + "name": "test_sha_citation_warning", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_sha_citation_warning", + "signature": "def test_sha_citation_warning(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 185, + "span": { + "end": { + "byte": 8845, + "column": 45, + "line": 185 + }, + "start": { + "byte": 8474, + "column": 4, + "line": 177 + } + }, + "start_line": 177 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_sha_citation_warning", + "identity": "ConsumerDriftTest.test_sha_citation_warning", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_stale_referenced_doctrine_is_drift/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_stale_referenced_doctrine_is_drift", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_stale_referenced_doctrine_is_drift", + "decorators": [], + "kind": "method", + "name": "test_stale_referenced_doctrine_is_drift", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_stale_referenced_doctrine_is_drift", + "signature": "def test_stale_referenced_doctrine_is_drift(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 238, + "span": { + "end": { + "byte": 11477, + "column": 95, + "line": 238 + }, + "start": { + "byte": 11224, + "column": 4, + "line": 235 + } + }, + "start_line": 235 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_stale_referenced_doctrine_is_drift", + "identity": "ConsumerDriftTest.test_stale_referenced_doctrine_is_drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_superseded_skill_fails_even_when_no_longer_canonical/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_superseded_skill_fails_even_when_no_longer_canonical", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_superseded_skill_fails_even_when_no_longer_canonical", + "decorators": [], + "kind": "method", + "name": "test_superseded_skill_fails_even_when_no_longer_canonical", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_superseded_skill_fails_even_when_no_longer_canonical", + "signature": "def test_superseded_skill_fails_even_when_no_longer_canonical(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 92, + "span": { + "end": { + "byte": 3902, + "column": 60, + "line": 92 + }, + "start": { + "byte": 3450, + "column": 4, + "line": 86 + } + }, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_superseded_skill_fails_even_when_no_longer_canonical", + "identity": "ConsumerDriftTest.test_superseded_skill_fails_even_when_no_longer_canonical", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_unreferenced_doctrine_not_required/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_unreferenced_doctrine_not_required", + "metadata_kind": "comment", + "text": "a doctrine file no vendored skill links to is not required in the consumer" + } + }, + "origin": "native", + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 241, + "span": { + "end": { + "byte": 11626, + "column": 84, + "line": 241 + }, + "start": { + "byte": 11550, + "column": 8, + "line": 241 + } + }, + "start_line": 241 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_unreferenced_doctrine_not_required", + "identity": "ConsumerDriftTest.test_unreferenced_doctrine_not_required", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_unreferenced_doctrine_not_required/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_unreferenced_doctrine_not_required", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_unreferenced_doctrine_not_required", + "decorators": [], + "kind": "method", + "name": "test_unreferenced_doctrine_not_required", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_unreferenced_doctrine_not_required", + "signature": "def test_unreferenced_doctrine_not_required(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 244, + "span": { + "end": { + "byte": 11765, + "column": 45, + "line": 244 + }, + "start": { + "byte": 11483, + "column": 4, + "line": 240 + } + }, + "start_line": 240 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_unreferenced_doctrine_not_required", + "identity": "ConsumerDriftTest.test_unreferenced_doctrine_not_required", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_verbatim_copy_is_clean/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerDriftTest.test_verbatim_copy_is_clean", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::method:ConsumerDriftTest.test_verbatim_copy_is_clean", + "decorators": [], + "kind": "method", + "name": "test_verbatim_copy_is_clean", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "qualified_name": "ConsumerDriftTest.test_verbatim_copy_is_clean", + "signature": "def test_verbatim_copy_is_clean(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 55, + "span": { + "end": { + "byte": 1994, + "column": 57, + "line": 55 + }, + "start": { + "byte": 1789, + "column": 4, + "line": 52 + } + }, + "start_line": 52 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest.test_verbatim_copy_is_clean", + "identity": "ConsumerDriftTest.test_verbatim_copy_is_clean", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "ConsumerDriftTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::class:ConsumerDriftTest", + "decorators": [], + "kind": "class", + "name": "ConsumerDriftTest", + "parent_identity": null, + "qualified_name": "ConsumerDriftTest", + "signature": "class ConsumerDriftTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 250, + "span": { + "end": { + "byte": 12033, + "column": 31, + "line": 250 + }, + "start": { + "byte": 608, + "column": 0, + "line": 24 + } + }, + "start_line": 24 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/ConsumerDriftTest", + "identity": "ConsumerDriftTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/_write/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_write", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_drift.py::function:_write", + "decorators": [], + "kind": "function", + "name": "_write", + "parent_identity": null, + "qualified_name": "_write", + "signature": "def _write(path: Path, text: str) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a8127dc141f4b87f1ca5addaf2e52b3c4dcf33d84727d288c2b474ecdbb5f940", + "file": "tests/test_consumer_drift.py", + "location": { + "end_line": 21, + "span": { + "end": { + "byte": 605, + "column": 43, + "line": 21 + }, + "start": { + "byte": 468, + "column": 0, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_drift.py#subject/symbol/_write", + "identity": "_write", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/module/tests%2Ftest_consumer_matrix.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_matrix.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Keep the documented active-consumer list aligned with the drift workflow.", + "text": "Keep the documented active-consumer list aligned with the drift workflow." + } + }, + "origin": "native", + "source": { + "content_sha256": "930f1cd3251d2ab7d4877699f0e89c1740a566e6757d2320d1672d0da576540d", + "file": "tests/test_consumer_matrix.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 79, + "column": 79, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/module/tests%2Ftest_consumer_matrix.py", + "identity": "tests/test_consumer_matrix.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/module/tests%2Ftest_consumer_matrix.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "930f1cd3251d2ab7d4877699f0e89c1740a566e6757d2320d1672d0da576540d", + "file": "tests/test_consumer_matrix.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/module/tests%2Ftest_consumer_matrix.py", + "identity": "tests/test_consumer_matrix.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/module/tests%2Ftest_consumer_matrix.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "930f1cd3251d2ab7d4877699f0e89c1740a566e6757d2320d1672d0da576540d", + "file": "tests/test_consumer_matrix.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/module/tests%2Ftest_consumer_matrix.py", + "identity": "tests/test_consumer_matrix.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/module/tests%2Ftest_consumer_matrix.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "930f1cd3251d2ab7d4877699f0e89c1740a566e6757d2320d1672d0da576540d", + "file": "tests/test_consumer_matrix.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/module/tests%2Ftest_consumer_matrix.py", + "identity": "tests/test_consumer_matrix.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/symbol/ConsumerMatrixTests.test_archived_edcmbone_is_not_an_active_drift_consumer/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerMatrixTests.test_archived_edcmbone_is_not_an_active_drift_consumer", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_matrix.py::method:ConsumerMatrixTests.test_archived_edcmbone_is_not_an_active_drift_consumer", + "decorators": [], + "kind": "method", + "name": "test_archived_edcmbone_is_not_an_active_drift_consumer", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_matrix.py::class:ConsumerMatrixTests", + "qualified_name": "ConsumerMatrixTests.test_archived_edcmbone_is_not_an_active_drift_consumer", + "signature": "def test_archived_edcmbone_is_not_an_active_drift_consumer(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "930f1cd3251d2ab7d4877699f0e89c1740a566e6757d2320d1672d0da576540d", + "file": "tests/test_consumer_matrix.py", + "location": { + "end_line": 43, + "span": { + "end": { + "byte": 1620, + "column": 47, + "line": 43 + }, + "start": { + "byte": 913, + "column": 4, + "line": 28 + } + }, + "start_line": 28 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/symbol/ConsumerMatrixTests.test_archived_edcmbone_is_not_an_active_drift_consumer", + "identity": "ConsumerMatrixTests.test_archived_edcmbone_is_not_an_active_drift_consumer", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/symbol/ConsumerMatrixTests.test_ptcna_is_an_active_drift_consumer/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerMatrixTests.test_ptcna_is_an_active_drift_consumer", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_matrix.py::method:ConsumerMatrixTests.test_ptcna_is_an_active_drift_consumer", + "decorators": [], + "kind": "method", + "name": "test_ptcna_is_an_active_drift_consumer", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_matrix.py::class:ConsumerMatrixTests", + "qualified_name": "ConsumerMatrixTests.test_ptcna_is_an_active_drift_consumer", + "signature": "def test_ptcna_is_an_active_drift_consumer(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "930f1cd3251d2ab7d4877699f0e89c1740a566e6757d2320d1672d0da576540d", + "file": "tests/test_consumer_matrix.py", + "location": { + "end_line": 26, + "span": { + "end": { + "byte": 907, + "column": 41, + "line": 26 + }, + "start": { + "byte": 228, + "column": 4, + "line": 11 + } + }, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/symbol/ConsumerMatrixTests.test_ptcna_is_an_active_drift_consumer", + "identity": "ConsumerMatrixTests.test_ptcna_is_an_active_drift_consumer", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/symbol/ConsumerMatrixTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "ConsumerMatrixTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_consumer_matrix.py::class:ConsumerMatrixTests", + "decorators": [], + "kind": "class", + "name": "ConsumerMatrixTests", + "parent_identity": null, + "qualified_name": "ConsumerMatrixTests", + "signature": "class ConsumerMatrixTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "930f1cd3251d2ab7d4877699f0e89c1740a566e6757d2320d1672d0da576540d", + "file": "tests/test_consumer_matrix.py", + "location": { + "end_line": 43, + "span": { + "end": { + "byte": 1620, + "column": 47, + "line": 43 + }, + "start": { + "byte": 178, + "column": 0, + "line": 10 + } + }, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_consumer_matrix.py#subject/symbol/ConsumerMatrixTests", + "identity": "ConsumerMatrixTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py", + "identity": "tests/test_distributed_publication_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py", + "identity": "tests/test_distributed_publication_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py", + "identity": "tests/test_distributed_publication_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py", + "identity": "tests/test_distributed_publication_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "frontmatter:frontmatter_for:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "frontmatter", + "name": "frontmatter_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/module/tests%2Ftest_distributed_publication_skill.py", + "identity": "tests/test_distributed_publication_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DistributedPublicationSkillTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::method:DistributedPublicationSkillTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::class:DistributedPublicationSkillTest", + "qualified_name": "DistributedPublicationSkillTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 21, + "span": { + "end": { + "byte": 668, + "column": 70, + "line": 21 + }, + "start": { + "byte": 402, + "column": 4, + "line": 17 + } + }, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.setUp", + "identity": "DistributedPublicationSkillTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_activation_and_non_trigger_are_explicit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DistributedPublicationSkillTest.test_activation_and_non_trigger_are_explicit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::method:DistributedPublicationSkillTest.test_activation_and_non_trigger_are_explicit", + "decorators": [], + "kind": "method", + "name": "test_activation_and_non_trigger_are_explicit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::class:DistributedPublicationSkillTest", + "qualified_name": "DistributedPublicationSkillTest.test_activation_and_non_trigger_are_explicit", + "signature": "def test_activation_and_non_trigger_are_explicit(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 30, + "span": { + "end": { + "byte": 1148, + "column": 69, + "line": 30 + }, + "start": { + "byte": 674, + "column": 4, + "line": 23 + } + }, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_activation_and_non_trigger_are_explicit", + "identity": "DistributedPublicationSkillTest.test_activation_and_non_trigger_are_explicit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_authority_and_status_do_not_transfer/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DistributedPublicationSkillTest.test_authority_and_status_do_not_transfer", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::method:DistributedPublicationSkillTest.test_authority_and_status_do_not_transfer", + "decorators": [], + "kind": "method", + "name": "test_authority_and_status_do_not_transfer", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::class:DistributedPublicationSkillTest", + "qualified_name": "DistributedPublicationSkillTest.test_authority_and_status_do_not_transfer", + "signature": "def test_authority_and_status_do_not_transfer(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 54, + "span": { + "end": { + "byte": 2298, + "column": 50, + "line": 54 + }, + "start": { + "byte": 1638, + "column": 4, + "line": 39 + } + }, + "start_line": 39 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_authority_and_status_do_not_transfer", + "identity": "DistributedPublicationSkillTest.test_authority_and_status_do_not_transfer", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_corrections_route_to_source_owners/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DistributedPublicationSkillTest.test_corrections_route_to_source_owners", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::method:DistributedPublicationSkillTest.test_corrections_route_to_source_owners", + "decorators": [], + "kind": "method", + "name": "test_corrections_route_to_source_owners", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::class:DistributedPublicationSkillTest", + "qualified_name": "DistributedPublicationSkillTest.test_corrections_route_to_source_owners", + "signature": "def test_corrections_route_to_source_owners(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 95, + "span": { + "end": { + "byte": 4342, + "column": 83, + "line": 95 + }, + "start": { + "byte": 4039, + "column": 4, + "line": 92 + } + }, + "start_line": 92 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_corrections_route_to_source_owners", + "identity": "DistributedPublicationSkillTest.test_corrections_route_to_source_owners", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_production_fails_closed_and_degraded_mode_stays_visible/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DistributedPublicationSkillTest.test_production_fails_closed_and_degraded_mode_stays_visible", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::method:DistributedPublicationSkillTest.test_production_fails_closed_and_degraded_mode_stays_visible", + "decorators": [], + "kind": "method", + "name": "test_production_fails_closed_and_degraded_mode_stays_visible", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::class:DistributedPublicationSkillTest", + "qualified_name": "DistributedPublicationSkillTest.test_production_fails_closed_and_degraded_mode_stays_visible", + "signature": "def test_production_fails_closed_and_degraded_mode_stays_visible(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 90, + "span": { + "end": { + "byte": 4033, + "column": 83, + "line": 90 + }, + "start": { + "byte": 3382, + "column": 4, + "line": 83 + } + }, + "start_line": 83 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_production_fails_closed_and_degraded_mode_stays_visible", + "identity": "DistributedPublicationSkillTest.test_production_fails_closed_and_degraded_mode_stays_visible", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_reference_contract_binds_order_identity_and_license/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DistributedPublicationSkillTest.test_reference_contract_binds_order_identity_and_license", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::method:DistributedPublicationSkillTest.test_reference_contract_binds_order_identity_and_license", + "decorators": [], + "kind": "method", + "name": "test_reference_contract_binds_order_identity_and_license", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::class:DistributedPublicationSkillTest", + "qualified_name": "DistributedPublicationSkillTest.test_reference_contract_binds_order_identity_and_license", + "signature": "def test_reference_contract_binds_order_identity_and_license(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 81, + "span": { + "end": { + "byte": 3376, + "column": 101, + "line": 81 + }, + "start": { + "byte": 2304, + "column": 4, + "line": 56 + } + }, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_reference_contract_binds_order_identity_and_license", + "identity": "DistributedPublicationSkillTest.test_reference_contract_binds_order_identity_and_license", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_reference_implementation_and_hmmm_remain_visible/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DistributedPublicationSkillTest.test_reference_implementation_and_hmmm_remain_visible", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::method:DistributedPublicationSkillTest.test_reference_implementation_and_hmmm_remain_visible", + "decorators": [], + "kind": "method", + "name": "test_reference_implementation_and_hmmm_remain_visible", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::class:DistributedPublicationSkillTest", + "qualified_name": "DistributedPublicationSkillTest.test_reference_implementation_and_hmmm_remain_visible", + "signature": "def test_reference_implementation_and_hmmm_remain_visible(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 109, + "span": { + "end": { + "byte": 5137, + "column": 71, + "line": 109 + }, + "start": { + "byte": 4728, + "column": 4, + "line": 103 + } + }, + "start_line": 103 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_reference_implementation_and_hmmm_remain_visible", + "identity": "DistributedPublicationSkillTest.test_reference_implementation_and_hmmm_remain_visible", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_skill_is_registered_as_procedural_and_composed_by_doctrine/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DistributedPublicationSkillTest.test_skill_is_registered_as_procedural_and_composed_by_doctrine", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::method:DistributedPublicationSkillTest.test_skill_is_registered_as_procedural_and_composed_by_doctrine", + "decorators": [], + "kind": "method", + "name": "test_skill_is_registered_as_procedural_and_composed_by_doctrine", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::class:DistributedPublicationSkillTest", + "qualified_name": "DistributedPublicationSkillTest.test_skill_is_registered_as_procedural_and_composed_by_doctrine", + "signature": "def test_skill_is_registered_as_procedural_and_composed_by_doctrine(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 37, + "span": { + "end": { + "byte": 1632, + "column": 107, + "line": 37 + }, + "start": { + "byte": 1154, + "column": 4, + "line": 32 + } + }, + "start_line": 32 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_skill_is_registered_as_procedural_and_composed_by_doctrine", + "identity": "DistributedPublicationSkillTest.test_skill_is_registered_as_procedural_and_composed_by_doctrine", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_static_accessible_publication_surface_is_required/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DistributedPublicationSkillTest.test_static_accessible_publication_surface_is_required", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::method:DistributedPublicationSkillTest.test_static_accessible_publication_surface_is_required", + "decorators": [], + "kind": "method", + "name": "test_static_accessible_publication_surface_is_required", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::class:DistributedPublicationSkillTest", + "qualified_name": "DistributedPublicationSkillTest.test_static_accessible_publication_surface_is_required", + "signature": "def test_static_accessible_publication_surface_is_required(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 101, + "span": { + "end": { + "byte": 4722, + "column": 87, + "line": 101 + }, + "start": { + "byte": 4348, + "column": 4, + "line": 97 + } + }, + "start_line": 97 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest.test_static_accessible_publication_surface_is_required", + "identity": "DistributedPublicationSkillTest.test_static_accessible_publication_surface_is_required", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "DistributedPublicationSkillTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_distributed_publication_skill.py::class:DistributedPublicationSkillTest", + "decorators": [], + "kind": "class", + "name": "DistributedPublicationSkillTest", + "parent_identity": null, + "qualified_name": "DistributedPublicationSkillTest", + "signature": "class DistributedPublicationSkillTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "b2b6c8b14884908bf03550afe3c38a2dc65e398dbe6b4db8dadf3829362838fc", + "file": "tests/test_distributed_publication_skill.py", + "location": { + "end_line": 109, + "span": { + "end": { + "byte": 5137, + "column": 71, + "line": 109 + }, + "start": { + "byte": 340, + "column": 0, + "line": 16 + } + }, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_distributed_publication_skill.py#subject/symbol/DistributedPublicationSkillTest", + "identity": "DistributedPublicationSkillTest", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py", + "identity": "tests/test_domain_claims_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py", + "identity": "tests/test_domain_claims_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py", + "identity": "tests/test_domain_claims_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "frontmatter:frontmatter_for:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "frontmatter", + "name": "frontmatter_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/module/tests%2Ftest_domain_claims_skill.py", + "identity": "tests/test_domain_claims_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DomainClaimsSkillTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::method:DomainClaimsSkillTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::class:DomainClaimsSkillTest", + "qualified_name": "DomainClaimsSkillTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 16, + "span": { + "end": { + "byte": 389, + "column": 49, + "line": 16 + }, + "start": { + "byte": 261, + "column": 4, + "line": 14 + } + }, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.setUp", + "identity": "DomainClaimsSkillTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_activation_and_non_trigger_are_explicit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DomainClaimsSkillTest.test_activation_and_non_trigger_are_explicit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::method:DomainClaimsSkillTest.test_activation_and_non_trigger_are_explicit", + "decorators": [], + "kind": "method", + "name": "test_activation_and_non_trigger_are_explicit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::class:DomainClaimsSkillTest", + "qualified_name": "DomainClaimsSkillTest.test_activation_and_non_trigger_are_explicit", + "signature": "def test_activation_and_non_trigger_are_explicit(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 24, + "span": { + "end": { + "byte": 776, + "column": 52, + "line": 24 + }, + "start": { + "byte": 395, + "column": 4, + "line": 18 + } + }, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_activation_and_non_trigger_are_explicit", + "identity": "DomainClaimsSkillTest.test_activation_and_non_trigger_are_explicit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_claim_record_and_fail_closed_collision_are_pinned/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DomainClaimsSkillTest.test_claim_record_and_fail_closed_collision_are_pinned", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::method:DomainClaimsSkillTest.test_claim_record_and_fail_closed_collision_are_pinned", + "decorators": [], + "kind": "method", + "name": "test_claim_record_and_fail_closed_collision_are_pinned", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::class:DomainClaimsSkillTest", + "qualified_name": "DomainClaimsSkillTest.test_claim_record_and_fail_closed_collision_are_pinned", + "signature": "def test_claim_record_and_fail_closed_collision_are_pinned(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 55, + "span": { + "end": { + "byte": 2124, + "column": 50, + "line": 55 + }, + "start": { + "byte": 1497, + "column": 4, + "line": 38 + } + }, + "start_line": 38 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_claim_record_and_fail_closed_collision_are_pinned", + "identity": "DomainClaimsSkillTest.test_claim_record_and_fail_closed_collision_are_pinned", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_domain_claim_precedes_definition_and_provenance/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DomainClaimsSkillTest.test_domain_claim_precedes_definition_and_provenance", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::method:DomainClaimsSkillTest.test_domain_claim_precedes_definition_and_provenance", + "decorators": [], + "kind": "method", + "name": "test_domain_claim_precedes_definition_and_provenance", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::class:DomainClaimsSkillTest", + "qualified_name": "DomainClaimsSkillTest.test_domain_claim_precedes_definition_and_provenance", + "signature": "def test_domain_claim_precedes_definition_and_provenance(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 36, + "span": { + "end": { + "byte": 1491, + "column": 47, + "line": 36 + }, + "start": { + "byte": 782, + "column": 4, + "line": 26 + } + }, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_domain_claim_precedes_definition_and_provenance", + "identity": "DomainClaimsSkillTest.test_domain_claim_precedes_definition_and_provenance", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_domain_claims_runs_before_canon/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DomainClaimsSkillTest.test_domain_claims_runs_before_canon", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::method:DomainClaimsSkillTest.test_domain_claims_runs_before_canon", + "decorators": [], + "kind": "method", + "name": "test_domain_claims_runs_before_canon", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::class:DomainClaimsSkillTest", + "qualified_name": "DomainClaimsSkillTest.test_domain_claims_runs_before_canon", + "signature": "def test_domain_claims_runs_before_canon(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 65, + "span": { + "end": { + "byte": 2666, + "column": 59, + "line": 65 + }, + "start": { + "byte": 2436, + "column": 4, + "line": 62 + } + }, + "start_line": 62 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_domain_claims_runs_before_canon", + "identity": "DomainClaimsSkillTest.test_domain_claims_runs_before_canon", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_hmmm_boundary_remains_visible/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DomainClaimsSkillTest.test_hmmm_boundary_remains_visible", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::method:DomainClaimsSkillTest.test_hmmm_boundary_remains_visible", + "decorators": [], + "kind": "method", + "name": "test_hmmm_boundary_remains_visible", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::class:DomainClaimsSkillTest", + "qualified_name": "DomainClaimsSkillTest.test_hmmm_boundary_remains_visible", + "signature": "def test_hmmm_boundary_remains_visible(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 70, + "span": { + "end": { + "byte": 2895, + "column": 65, + "line": 70 + }, + "start": { + "byte": 2672, + "column": 4, + "line": 67 + } + }, + "start_line": 67 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_hmmm_boundary_remains_visible", + "identity": "DomainClaimsSkillTest.test_hmmm_boundary_remains_visible", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_skill_refuses_global_word_ownership_and_registry_overreach/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "DomainClaimsSkillTest.test_skill_refuses_global_word_ownership_and_registry_overreach", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::method:DomainClaimsSkillTest.test_skill_refuses_global_word_ownership_and_registry_overreach", + "decorators": [], + "kind": "method", + "name": "test_skill_refuses_global_word_ownership_and_registry_overreach", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::class:DomainClaimsSkillTest", + "qualified_name": "DomainClaimsSkillTest.test_skill_refuses_global_word_ownership_and_registry_overreach", + "signature": "def test_skill_refuses_global_word_ownership_and_registry_overreach(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 60, + "span": { + "end": { + "byte": 2430, + "column": 82, + "line": 60 + }, + "start": { + "byte": 2130, + "column": 4, + "line": 57 + } + }, + "start_line": 57 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest.test_skill_refuses_global_word_ownership_and_registry_overreach", + "identity": "DomainClaimsSkillTest.test_skill_refuses_global_word_ownership_and_registry_overreach", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "DomainClaimsSkillTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_domain_claims_skill.py::class:DomainClaimsSkillTest", + "decorators": [], + "kind": "class", + "name": "DomainClaimsSkillTest", + "parent_identity": null, + "qualified_name": "DomainClaimsSkillTest", + "signature": "class DomainClaimsSkillTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fd7be53f3b3be3682262d4d956bd92abb3d9f211dea1ed9ea747f4b1379ef5d4", + "file": "tests/test_domain_claims_skill.py", + "location": { + "end_line": 70, + "span": { + "end": { + "byte": 2895, + "column": 65, + "line": 70 + }, + "start": { + "byte": 209, + "column": 0, + "line": 13 + } + }, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_domain_claims_skill.py#subject/symbol/DomainClaimsSkillTest", + "identity": "DomainClaimsSkillTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py", + "identity": "tests/test_epac_selection_display_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py", + "identity": "tests/test_epac_selection_display_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py", + "identity": "tests/test_epac_selection_display_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py", + "identity": "tests/test_epac_selection_display_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "frontmatter:frontmatter_for:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "frontmatter", + "name": "frontmatter_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/module/tests%2Ftest_epac_selection_display_skill.py", + "identity": "tests/test_epac_selection_display_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "EpacSelectionDisplaySkillTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::method:EpacSelectionDisplaySkillTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::class:EpacSelectionDisplaySkillTest", + "qualified_name": "EpacSelectionDisplaySkillTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 24, + "span": { + "end": { + "byte": 817, + "column": 49, + "line": 24 + }, + "start": { + "byte": 638, + "column": 4, + "line": 21 + } + }, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.setUp", + "identity": "EpacSelectionDisplaySkillTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_activation_and_nontrigger_are_discriminating/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "EpacSelectionDisplaySkillTest.test_activation_and_nontrigger_are_discriminating", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::method:EpacSelectionDisplaySkillTest.test_activation_and_nontrigger_are_discriminating", + "decorators": [], + "kind": "method", + "name": "test_activation_and_nontrigger_are_discriminating", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::class:EpacSelectionDisplaySkillTest", + "qualified_name": "EpacSelectionDisplaySkillTest.test_activation_and_nontrigger_are_discriminating", + "signature": "def test_activation_and_nontrigger_are_discriminating(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 37, + "span": { + "end": { + "byte": 1502, + "column": 121, + "line": 37 + }, + "start": { + "byte": 823, + "column": 4, + "line": 26 + } + }, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_activation_and_nontrigger_are_discriminating", + "identity": "EpacSelectionDisplaySkillTest.test_activation_and_nontrigger_are_discriminating", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_audience_and_destination_survive_output/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "EpacSelectionDisplaySkillTest.test_audience_and_destination_survive_output", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::method:EpacSelectionDisplaySkillTest.test_audience_and_destination_survive_output", + "decorators": [], + "kind": "method", + "name": "test_audience_and_destination_survive_output", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::class:EpacSelectionDisplaySkillTest", + "qualified_name": "EpacSelectionDisplaySkillTest.test_audience_and_destination_survive_output", + "signature": "def test_audience_and_destination_survive_output(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 90, + "span": { + "end": { + "byte": 4200, + "column": 66, + "line": 90 + }, + "start": { + "byte": 3890, + "column": 4, + "line": 86 + } + }, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_audience_and_destination_survive_output", + "identity": "EpacSelectionDisplaySkillTest.test_audience_and_destination_survive_output", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_display_selection_never_promotes_status/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "EpacSelectionDisplaySkillTest.test_display_selection_never_promotes_status", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::method:EpacSelectionDisplaySkillTest.test_display_selection_never_promotes_status", + "decorators": [], + "kind": "method", + "name": "test_display_selection_never_promotes_status", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::class:EpacSelectionDisplaySkillTest", + "qualified_name": "EpacSelectionDisplaySkillTest.test_display_selection_never_promotes_status", + "signature": "def test_display_selection_never_promotes_status(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 46, + "span": { + "end": { + "byte": 1835, + "column": 44, + "line": 46 + }, + "start": { + "byte": 1508, + "column": 4, + "line": 39 + } + }, + "start_line": 39 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_display_selection_never_promotes_status", + "identity": "EpacSelectionDisplaySkillTest.test_display_selection_never_promotes_status", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_handle_and_provisional_source_boundaries_are_explicit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "EpacSelectionDisplaySkillTest.test_handle_and_provisional_source_boundaries_are_explicit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::method:EpacSelectionDisplaySkillTest.test_handle_and_provisional_source_boundaries_are_explicit", + "decorators": [], + "kind": "method", + "name": "test_handle_and_provisional_source_boundaries_are_explicit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::class:EpacSelectionDisplaySkillTest", + "qualified_name": "EpacSelectionDisplaySkillTest.test_handle_and_provisional_source_boundaries_are_explicit", + "signature": "def test_handle_and_provisional_source_boundaries_are_explicit(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 52, + "span": { + "end": { + "byte": 2202, + "column": 53, + "line": 52 + }, + "start": { + "byte": 1841, + "column": 4, + "line": 48 + } + }, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_handle_and_provisional_source_boundaries_are_explicit", + "identity": "EpacSelectionDisplaySkillTest.test_handle_and_provisional_source_boundaries_are_explicit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_index_and_adapter_expose_the_canonical_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "EpacSelectionDisplaySkillTest.test_index_and_adapter_expose_the_canonical_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::method:EpacSelectionDisplaySkillTest.test_index_and_adapter_expose_the_canonical_skill", + "decorators": [], + "kind": "method", + "name": "test_index_and_adapter_expose_the_canonical_skill", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::class:EpacSelectionDisplaySkillTest", + "qualified_name": "EpacSelectionDisplaySkillTest.test_index_and_adapter_expose_the_canonical_skill", + "signature": "def test_index_and_adapter_expose_the_canonical_skill(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 116, + "span": { + "end": { + "byte": 5629, + "column": 98, + "line": 116 + }, + "start": { + "byte": 4958, + "column": 4, + "line": 107 + } + }, + "start_line": 107 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_index_and_adapter_expose_the_canonical_skill", + "identity": "EpacSelectionDisplaySkillTest.test_index_and_adapter_expose_the_canonical_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_provisional_source_pin_has_immutable_stack_fixture/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "EpacSelectionDisplaySkillTest.test_provisional_source_pin_has_immutable_stack_fixture", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::method:EpacSelectionDisplaySkillTest.test_provisional_source_pin_has_immutable_stack_fixture", + "decorators": [], + "kind": "method", + "name": "test_provisional_source_pin_has_immutable_stack_fixture", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::class:EpacSelectionDisplaySkillTest", + "qualified_name": "EpacSelectionDisplaySkillTest.test_provisional_source_pin_has_immutable_stack_fixture", + "signature": "def test_provisional_source_pin_has_immutable_stack_fixture(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 73, + "span": { + "end": { + "byte": 3352, + "column": 40, + "line": 73 + }, + "start": { + "byte": 2208, + "column": 4, + "line": 54 + } + }, + "start_line": 54 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_provisional_source_pin_has_immutable_stack_fixture", + "identity": "EpacSelectionDisplaySkillTest.test_provisional_source_pin_has_immutable_stack_fixture", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_sealed_comparison_and_invented_geometry_are_blocked/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "EpacSelectionDisplaySkillTest.test_sealed_comparison_and_invented_geometry_are_blocked", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::method:EpacSelectionDisplaySkillTest.test_sealed_comparison_and_invented_geometry_are_blocked", + "decorators": [], + "kind": "method", + "name": "test_sealed_comparison_and_invented_geometry_are_blocked", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::class:EpacSelectionDisplaySkillTest", + "qualified_name": "EpacSelectionDisplaySkillTest.test_sealed_comparison_and_invented_geometry_are_blocked", + "signature": "def test_sealed_comparison_and_invented_geometry_are_blocked(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 105, + "span": { + "end": { + "byte": 4952, + "column": 55, + "line": 105 + }, + "start": { + "byte": 4562, + "column": 4, + "line": 101 + } + }, + "start_line": 101 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_sealed_comparison_and_invented_geometry_are_blocked", + "identity": "EpacSelectionDisplaySkillTest.test_sealed_comparison_and_invented_geometry_are_blocked", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_target_receipt_and_representation_are_verified/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "EpacSelectionDisplaySkillTest.test_target_receipt_and_representation_are_verified", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::method:EpacSelectionDisplaySkillTest.test_target_receipt_and_representation_are_verified", + "decorators": [], + "kind": "method", + "name": "test_target_receipt_and_representation_are_verified", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::class:EpacSelectionDisplaySkillTest", + "qualified_name": "EpacSelectionDisplaySkillTest.test_target_receipt_and_representation_are_verified", + "signature": "def test_target_receipt_and_representation_are_verified(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 84, + "span": { + "end": { + "byte": 3884, + "column": 44, + "line": 84 + }, + "start": { + "byte": 3358, + "column": 4, + "line": 75 + } + }, + "start_line": 75 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_target_receipt_and_representation_are_verified", + "identity": "EpacSelectionDisplaySkillTest.test_target_receipt_and_representation_are_verified", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_webmcp_remains_a_read_only_handoff/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "EpacSelectionDisplaySkillTest.test_webmcp_remains_a_read_only_handoff", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::method:EpacSelectionDisplaySkillTest.test_webmcp_remains_a_read_only_handoff", + "decorators": [], + "kind": "method", + "name": "test_webmcp_remains_a_read_only_handoff", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::class:EpacSelectionDisplaySkillTest", + "qualified_name": "EpacSelectionDisplaySkillTest.test_webmcp_remains_a_read_only_handoff", + "signature": "def test_webmcp_remains_a_read_only_handoff(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 99, + "span": { + "end": { + "byte": 4556, + "column": 44, + "line": 99 + }, + "start": { + "byte": 4206, + "column": 4, + "line": 92 + } + }, + "start_line": 92 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest.test_webmcp_remains_a_read_only_handoff", + "identity": "EpacSelectionDisplaySkillTest.test_webmcp_remains_a_read_only_handoff", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "EpacSelectionDisplaySkillTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_epac_selection_display_skill.py::class:EpacSelectionDisplaySkillTest", + "decorators": [], + "kind": "class", + "name": "EpacSelectionDisplaySkillTest", + "parent_identity": null, + "qualified_name": "EpacSelectionDisplaySkillTest", + "signature": "class EpacSelectionDisplaySkillTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "2845c4434143485eb66b95e54ae935ed16c934d3d53781b2ec6c1b5cffa99470", + "file": "tests/test_epac_selection_display_skill.py", + "location": { + "end_line": 116, + "span": { + "end": { + "byte": 5629, + "column": 98, + "line": 116 + }, + "start": { + "byte": 578, + "column": 0, + "line": 20 + } + }, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_epac_selection_display_skill.py#subject/symbol/EpacSelectionDisplaySkillTest", + "identity": "EpacSelectionDisplaySkillTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "68cf19d6a44fdb3cf06d635af2e2b1615ff7f5092054bce18bf8e4068a76e549", + "file": "tests/test_frontmatter.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py", + "identity": "tests/test_frontmatter.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "68cf19d6a44fdb3cf06d635af2e2b1615ff7f5092054bce18bf8e4068a76e549", + "file": "tests/test_frontmatter.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py", + "identity": "tests/test_frontmatter.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "68cf19d6a44fdb3cf06d635af2e2b1615ff7f5092054bce18bf8e4068a76e549", + "file": "tests/test_frontmatter.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py", + "identity": "tests/test_frontmatter.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "68cf19d6a44fdb3cf06d635af2e2b1615ff7f5092054bce18bf8e4068a76e549", + "file": "tests/test_frontmatter.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py", + "identity": "tests/test_frontmatter.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "frontmatter:frontmatter_for:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "frontmatter", + "name": "frontmatter_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "68cf19d6a44fdb3cf06d635af2e2b1615ff7f5092054bce18bf8e4068a76e549", + "file": "tests/test_frontmatter.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/module/tests%2Ftest_frontmatter.py", + "identity": "tests/test_frontmatter.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/symbol/FrontmatterParserTest.parse/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "FrontmatterParserTest.parse", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_frontmatter.py::method:FrontmatterParserTest.parse", + "decorators": [], + "kind": "method", + "name": "parse", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_frontmatter.py::class:FrontmatterParserTest", + "qualified_name": "FrontmatterParserTest.parse", + "signature": "def parse(self, body: str) -> dict[str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "68cf19d6a44fdb3cf06d635af2e2b1615ff7f5092054bce18bf8e4068a76e549", + "file": "tests/test_frontmatter.py", + "location": { + "end_line": 15, + "span": { + "end": { + "byte": 442, + "column": 40, + "line": 15 + }, + "start": { + "byte": 188, + "column": 4, + "line": 11 + } + }, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/symbol/FrontmatterParserTest.parse", + "identity": "FrontmatterParserTest.parse", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/symbol/FrontmatterParserTest.test_parses_folded_description/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "FrontmatterParserTest.test_parses_folded_description", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_frontmatter.py::method:FrontmatterParserTest.test_parses_folded_description", + "decorators": [], + "kind": "method", + "name": "test_parses_folded_description", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_frontmatter.py::class:FrontmatterParserTest", + "qualified_name": "FrontmatterParserTest.test_parses_folded_description", + "signature": "def test_parses_folded_description(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "68cf19d6a44fdb3cf06d635af2e2b1615ff7f5092054bce18bf8e4068a76e549", + "file": "tests/test_frontmatter.py", + "location": { + "end_line": 29, + "span": { + "end": { + "byte": 934, + "column": 9, + "line": 29 + }, + "start": { + "byte": 448, + "column": 4, + "line": 17 + } + }, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/symbol/FrontmatterParserTest.test_parses_folded_description", + "identity": "FrontmatterParserTest.test_parses_folded_description", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/symbol/FrontmatterParserTest.test_parses_literal_description/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "FrontmatterParserTest.test_parses_literal_description", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_frontmatter.py::method:FrontmatterParserTest.test_parses_literal_description", + "decorators": [], + "kind": "method", + "name": "test_parses_literal_description", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_frontmatter.py::class:FrontmatterParserTest", + "qualified_name": "FrontmatterParserTest.test_parses_literal_description", + "signature": "def test_parses_literal_description(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "68cf19d6a44fdb3cf06d635af2e2b1615ff7f5092054bce18bf8e4068a76e549", + "file": "tests/test_frontmatter.py", + "location": { + "end_line": 39, + "span": { + "end": { + "byte": 1227, + "column": 74, + "line": 39 + }, + "start": { + "byte": 940, + "column": 4, + "line": 31 + } + }, + "start_line": 31 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/symbol/FrontmatterParserTest.test_parses_literal_description", + "identity": "FrontmatterParserTest.test_parses_literal_description", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/symbol/FrontmatterParserTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "FrontmatterParserTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_frontmatter.py::class:FrontmatterParserTest", + "decorators": [], + "kind": "class", + "name": "FrontmatterParserTest", + "parent_identity": null, + "qualified_name": "FrontmatterParserTest", + "signature": "class FrontmatterParserTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "68cf19d6a44fdb3cf06d635af2e2b1615ff7f5092054bce18bf8e4068a76e549", + "file": "tests/test_frontmatter.py", + "location": { + "end_line": 39, + "span": { + "end": { + "byte": 1227, + "column": 74, + "line": 39 + }, + "start": { + "byte": 136, + "column": 0, + "line": 10 + } + }, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_frontmatter.py#subject/symbol/FrontmatterParserTest", + "identity": "FrontmatterParserTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py", + "identity": "tests/test_gonol_build_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py", + "identity": "tests/test_gonol_build_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py", + "identity": "tests/test_gonol_build_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "frontmatter:frontmatter_for:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "frontmatter", + "name": "frontmatter_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/module/tests%2Ftest_gonol_build_skill.py", + "identity": "tests/test_gonol_build_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 19, + "span": { + "end": { + "byte": 545, + "column": 49, + "line": 19 + }, + "start": { + "byte": 366, + "column": 4, + "line": 16 + } + }, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.setUp", + "identity": "GonolBuildSkillTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_activation_contract_is_concrete/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_activation_contract_is_concrete", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_activation_contract_is_concrete", + "decorators": [], + "kind": "method", + "name": "test_activation_contract_is_concrete", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_activation_contract_is_concrete", + "signature": "def test_activation_contract_is_concrete(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 31, + "span": { + "end": { + "byte": 1018, + "column": 46, + "line": 31 + }, + "start": { + "byte": 551, + "column": 4, + "line": 21 + } + }, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_activation_contract_is_concrete", + "identity": "GonolBuildSkillTest.test_activation_contract_is_concrete", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_active_construction_resolves_stack_workspace/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_active_construction_resolves_stack_workspace", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_active_construction_resolves_stack_workspace", + "decorators": [], + "kind": "method", + "name": "test_active_construction_resolves_stack_workspace", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_active_construction_resolves_stack_workspace", + "signature": "def test_active_construction_resolves_stack_workspace(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 49, + "span": { + "end": { + "byte": 1976, + "column": 54, + "line": 49 + }, + "start": { + "byte": 1607, + "column": 4, + "line": 44 + } + }, + "start_line": 44 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_active_construction_resolves_stack_workspace", + "identity": "GonolBuildSkillTest.test_active_construction_resolves_stack_workspace", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_anti_patterns_preserve_explicit_contract_exceptions/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_anti_patterns_preserve_explicit_contract_exceptions", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_anti_patterns_preserve_explicit_contract_exceptions", + "decorators": [], + "kind": "method", + "name": "test_anti_patterns_preserve_explicit_contract_exceptions", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_anti_patterns_preserve_explicit_contract_exceptions", + "signature": "def test_anti_patterns_preserve_explicit_contract_exceptions(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 145, + "span": { + "end": { + "byte": 6849, + "column": 9, + "line": 145 + }, + "start": { + "byte": 6464, + "column": 4, + "line": 136 + } + }, + "start_line": 136 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_anti_patterns_preserve_explicit_contract_exceptions", + "identity": "GonolBuildSkillTest.test_anti_patterns_preserve_explicit_contract_exceptions", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_authority_split_is_current/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_authority_split_is_current", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_authority_split_is_current", + "decorators": [], + "kind": "method", + "name": "test_authority_split_is_current", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_authority_split_is_current", + "signature": "def test_authority_split_is_current(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 42, + "span": { + "end": { + "byte": 1601, + "column": 80, + "line": 42 + }, + "start": { + "byte": 1024, + "column": 4, + "line": 33 + } + }, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_authority_split_is_current", + "identity": "GonolBuildSkillTest.test_authority_split_is_current", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_closed_gonols_participate_atomically/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_closed_gonols_participate_atomically", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_closed_gonols_participate_atomically", + "decorators": [], + "kind": "method", + "name": "test_closed_gonols_participate_atomically", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_closed_gonols_participate_atomically", + "signature": "def test_closed_gonols_participate_atomically(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 66, + "span": { + "end": { + "byte": 2769, + "column": 47, + "line": 66 + }, + "start": { + "byte": 2290, + "column": 4, + "line": 59 + } + }, + "start_line": 59 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_closed_gonols_participate_atomically", + "identity": "GonolBuildSkillTest.test_closed_gonols_participate_atomically", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_codex_adapter_points_to_canonical_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_codex_adapter_points_to_canonical_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_codex_adapter_points_to_canonical_skill", + "decorators": [], + "kind": "method", + "name": "test_codex_adapter_points_to_canonical_skill", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_codex_adapter_points_to_canonical_skill", + "signature": "def test_codex_adapter_points_to_canonical_skill(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 158, + "span": { + "end": { + "byte": 7701, + "column": 61, + "line": 158 + }, + "start": { + "byte": 7319, + "column": 4, + "line": 153 + } + }, + "start_line": 153 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_codex_adapter_points_to_canonical_skill", + "identity": "GonolBuildSkillTest.test_codex_adapter_points_to_canonical_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_completion_preserves_resource_and_replay_boundary/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_completion_preserves_resource_and_replay_boundary", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_completion_preserves_resource_and_replay_boundary", + "decorators": [], + "kind": "method", + "name": "test_completion_preserves_resource_and_replay_boundary", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_completion_preserves_resource_and_replay_boundary", + "signature": "def test_completion_preserves_resource_and_replay_boundary(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 114, + "span": { + "end": { + "byte": 5212, + "column": 47, + "line": 114 + }, + "start": { + "byte": 4509, + "column": 4, + "line": 103 + } + }, + "start_line": 103 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_completion_preserves_resource_and_replay_boundary", + "identity": "GonolBuildSkillTest.test_completion_preserves_resource_and_replay_boundary", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_construction_invariant_preserves_identity_relation_and_provenance/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_construction_invariant_preserves_identity_relation_and_provenance", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_construction_invariant_preserves_identity_relation_and_provenance", + "decorators": [], + "kind": "method", + "name": "test_construction_invariant_preserves_identity_relation_and_provenance", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_construction_invariant_preserves_identity_relation_and_provenance", + "signature": "def test_construction_invariant_preserves_identity_relation_and_provenance(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 93, + "span": { + "end": { + "byte": 4124, + "column": 47, + "line": 93 + }, + "start": { + "byte": 3590, + "column": 4, + "line": 85 + } + }, + "start_line": 85 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_construction_invariant_preserves_identity_relation_and_provenance", + "identity": "GonolBuildSkillTest.test_construction_invariant_preserves_identity_relation_and_provenance", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_gonol_object_authority_remains_ucns/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_gonol_object_authority_remains_ucns", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_gonol_object_authority_remains_ucns", + "decorators": [], + "kind": "method", + "name": "test_gonol_object_authority_remains_ucns", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_gonol_object_authority_remains_ucns", + "signature": "def test_gonol_object_authority_remains_ucns(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 57, + "span": { + "end": { + "byte": 2284, + "column": 47, + "line": 57 + }, + "start": { + "byte": 1982, + "column": 4, + "line": 51 + } + }, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_gonol_object_authority_remains_ucns", + "identity": "GonolBuildSkillTest.test_gonol_object_authority_remains_ucns", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_local_authority_gate_is_named/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_local_authority_gate_is_named", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_local_authority_gate_is_named", + "decorators": [], + "kind": "method", + "name": "test_local_authority_gate_is_named", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_local_authority_gate_is_named", + "signature": "def test_local_authority_gate_is_named(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 101, + "span": { + "end": { + "byte": 4503, + "column": 71, + "line": 101 + }, + "start": { + "byte": 4335, + "column": 4, + "line": 99 + } + }, + "start_line": 99 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_local_authority_gate_is_named", + "identity": "GonolBuildSkillTest.test_local_authority_gate_is_named", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_no_undeclared_intermediate_or_substitute_representation/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_no_undeclared_intermediate_or_substitute_representation", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_no_undeclared_intermediate_or_substitute_representation", + "decorators": [], + "kind": "method", + "name": "test_no_undeclared_intermediate_or_substitute_representation", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_no_undeclared_intermediate_or_substitute_representation", + "signature": "def test_no_undeclared_intermediate_or_substitute_representation(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 74, + "span": { + "end": { + "byte": 3167, + "column": 47, + "line": 74 + }, + "start": { + "byte": 2775, + "column": 4, + "line": 68 + } + }, + "start_line": 68 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_no_undeclared_intermediate_or_substitute_representation", + "identity": "GonolBuildSkillTest.test_no_undeclared_intermediate_or_substitute_representation", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_pronunciation_is_inert_by_default/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_pronunciation_is_inert_by_default", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_pronunciation_is_inert_by_default", + "decorators": [], + "kind": "method", + "name": "test_pronunciation_is_inert_by_default", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_pronunciation_is_inert_by_default", + "signature": "def test_pronunciation_is_inert_by_default(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 83, + "span": { + "end": { + "byte": 3584, + "column": 47, + "line": 83 + }, + "start": { + "byte": 3173, + "column": 4, + "line": 76 + } + }, + "start_line": 76 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_pronunciation_is_inert_by_default", + "identity": "GonolBuildSkillTest.test_pronunciation_is_inert_by_default", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_unresolved_geometry_stays_hmmm/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_unresolved_geometry_stays_hmmm", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_unresolved_geometry_stays_hmmm", + "decorators": [], + "kind": "method", + "name": "test_unresolved_geometry_stays_hmmm", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_unresolved_geometry_stays_hmmm", + "signature": "def test_unresolved_geometry_stays_hmmm(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 97, + "span": { + "end": { + "byte": 4329, + "column": 75, + "line": 97 + }, + "start": { + "byte": 4130, + "column": 4, + "line": 95 + } + }, + "start_line": 95 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_unresolved_geometry_stays_hmmm", + "identity": "GonolBuildSkillTest.test_unresolved_geometry_stays_hmmm", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_usage_guidance_repeats_operational_contract/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_usage_guidance_repeats_operational_contract", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_usage_guidance_repeats_operational_contract", + "decorators": [], + "kind": "method", + "name": "test_usage_guidance_repeats_operational_contract", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_usage_guidance_repeats_operational_contract", + "signature": "def test_usage_guidance_repeats_operational_contract(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 151, + "span": { + "end": { + "byte": 7313, + "column": 106, + "line": 151 + }, + "start": { + "byte": 6855, + "column": 4, + "line": 147 + } + }, + "start_line": 147 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_usage_guidance_repeats_operational_contract", + "identity": "GonolBuildSkillTest.test_usage_guidance_repeats_operational_contract", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_workflow_and_anti_patterns_are_named/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_workflow_and_anti_patterns_are_named", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_workflow_and_anti_patterns_are_named", + "decorators": [], + "kind": "method", + "name": "test_workflow_and_anti_patterns_are_named", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_workflow_and_anti_patterns_are_named", + "signature": "def test_workflow_and_anti_patterns_are_named(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 134, + "span": { + "end": { + "byte": 6458, + "column": 104, + "line": 134 + }, + "start": { + "byte": 6074, + "column": 4, + "line": 130 + } + }, + "start_line": 130 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_workflow_and_anti_patterns_are_named", + "identity": "GonolBuildSkillTest.test_workflow_and_anti_patterns_are_named", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_workflow_preflights_before_constructor_resolution_and_replays_conditionally/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "GonolBuildSkillTest.test_workflow_preflights_before_constructor_resolution_and_replays_conditionally", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::method:GonolBuildSkillTest.test_workflow_preflights_before_constructor_resolution_and_replays_conditionally", + "decorators": [], + "kind": "method", + "name": "test_workflow_preflights_before_constructor_resolution_and_replays_conditionally", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "qualified_name": "GonolBuildSkillTest.test_workflow_preflights_before_constructor_resolution_and_replays_conditionally", + "signature": "def test_workflow_preflights_before_constructor_resolution_and_replays_conditionally(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 128, + "span": { + "end": { + "byte": 6068, + "column": 9, + "line": 128 + }, + "start": { + "byte": 5218, + "column": 4, + "line": 116 + } + }, + "start_line": 116 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest.test_workflow_preflights_before_constructor_resolution_and_replays_conditionally", + "identity": "GonolBuildSkillTest.test_workflow_preflights_before_constructor_resolution_and_replays_conditionally", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "GonolBuildSkillTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_gonol_build_skill.py::class:GonolBuildSkillTest", + "decorators": [], + "kind": "class", + "name": "GonolBuildSkillTest", + "parent_identity": null, + "qualified_name": "GonolBuildSkillTest", + "signature": "class GonolBuildSkillTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "df7b290bf0044be32552c02c683b4dbaf49732ee19a710c76f705d1da10cac20", + "file": "tests/test_gonol_build_skill.py", + "location": { + "end_line": 158, + "span": { + "end": { + "byte": 7701, + "column": 61, + "line": 158 + }, + "start": { + "byte": 316, + "column": 0, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_gonol_build_skill.py#subject/symbol/GonolBuildSkillTest", + "identity": "GonolBuildSkillTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "39:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A98-98/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "39:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 98, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "6:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A98-98/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "6:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 98, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "86:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A98-98/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "86:0" + } + }, + "origin": "native", + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 98, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=86:0 imports_exports=6:1 calls_definitions=39:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 70, + "column": 70, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "identity": "tests/test_harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=86:0 imports_exports=6:1 calls_definitions=39:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 98, + "span": { + "end": { + "byte": 4005, + "column": 70, + "line": 98 + }, + "start": { + "byte": 3935, + "column": 0, + "line": 98 + } + }, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "identity": "tests/test_harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "math:math:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "math", + "name": "math" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "identity": "tests/test_harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "identity": "tests/test_harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "identity": "tests/test_harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "identity": "tests/test_harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "identity": "tests/test_harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "harmonics:harmonics:5", + "value": { + "alias": "H", + "kind": "import", + "level": 0, + "module": "harmonics", + "name": "harmonics" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/module/tests%2Ftest_harmonics.py", + "identity": "tests/test_harmonics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_contrast_preserves_zero_zero_as_undefined/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "HarmonicsTest.test_contrast_preserves_zero_zero_as_undefined", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::method:HarmonicsTest.test_contrast_preserves_zero_zero_as_undefined", + "decorators": [], + "kind": "method", + "name": "test_contrast_preserves_zero_zero_as_undefined", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::class:HarmonicsTest", + "qualified_name": "HarmonicsTest.test_contrast_preserves_zero_zero_as_undefined", + "signature": "def test_contrast_preserves_zero_zero_as_undefined(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 39, + "span": { + "end": { + "byte": 1513, + "column": 55, + "line": 39 + }, + "start": { + "byte": 1348, + "column": 4, + "line": 37 + } + }, + "start_line": 37 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_contrast_preserves_zero_zero_as_undefined", + "identity": "HarmonicsTest.test_contrast_preserves_zero_zero_as_undefined", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_cycle_graph_groups_degenerate_modes/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "HarmonicsTest.test_cycle_graph_groups_degenerate_modes", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::method:HarmonicsTest.test_cycle_graph_groups_degenerate_modes", + "decorators": [], + "kind": "method", + "name": "test_cycle_graph_groups_degenerate_modes", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::class:HarmonicsTest", + "qualified_name": "HarmonicsTest.test_cycle_graph_groups_degenerate_modes", + "signature": "def test_cycle_graph_groups_degenerate_modes(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 27, + "span": { + "end": { + "byte": 961, + "column": 74, + "line": 27 + }, + "start": { + "byte": 308, + "column": 4, + "line": 14 + } + }, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_cycle_graph_groups_degenerate_modes", + "identity": "HarmonicsTest.test_cycle_graph_groups_degenerate_modes", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_harmonic_scan_finds_two_cycles/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "HarmonicsTest.test_harmonic_scan_finds_two_cycles", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::method:HarmonicsTest.test_harmonic_scan_finds_two_cycles", + "decorators": [], + "kind": "method", + "name": "test_harmonic_scan_finds_two_cycles", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::class:HarmonicsTest", + "qualified_name": "HarmonicsTest.test_harmonic_scan_finds_two_cycles", + "signature": "def test_harmonic_scan_finds_two_cycles(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 35, + "span": { + "end": { + "byte": 1342, + "column": 51, + "line": 35 + }, + "start": { + "byte": 967, + "column": 4, + "line": 29 + } + }, + "start_line": 29 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_harmonic_scan_finds_two_cycles", + "identity": "HarmonicsTest.test_harmonic_scan_finds_two_cycles", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_import_domain_runs_end_to_end/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "HarmonicsTest.test_import_domain_runs_end_to_end", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::method:HarmonicsTest.test_import_domain_runs_end_to_end", + "decorators": [], + "kind": "method", + "name": "test_import_domain_runs_end_to_end", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::class:HarmonicsTest", + "qualified_name": "HarmonicsTest.test_import_domain_runs_end_to_end", + "signature": "def test_import_domain_runs_end_to_end(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 93, + "span": { + "end": { + "byte": 3885, + "column": 35, + "line": 93 + }, + "start": { + "byte": 3085, + "column": 4, + "line": 77 + } + }, + "start_line": 77 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_import_domain_runs_end_to_end", + "identity": "HarmonicsTest.test_import_domain_runs_end_to_end", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_semantic_graph_projects_ids_to_files/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "HarmonicsTest.test_semantic_graph_projects_ids_to_files", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::method:HarmonicsTest.test_semantic_graph_projects_ids_to_files", + "decorators": [], + "kind": "method", + "name": "test_semantic_graph_projects_ids_to_files", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::class:HarmonicsTest", + "qualified_name": "HarmonicsTest.test_semantic_graph_projects_ids_to_files", + "signature": "def test_semantic_graph_projects_ids_to_files(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 59, + "span": { + "end": { + "byte": 2371, + "column": 76, + "line": 59 + }, + "start": { + "byte": 1519, + "column": 4, + "line": 41 + } + }, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_semantic_graph_projects_ids_to_files", + "identity": "HarmonicsTest.test_semantic_graph_projects_ids_to_files", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_source_balance_excludes_ratio_seals/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "HarmonicsTest.test_source_balance_excludes_ratio_seals", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::method:HarmonicsTest.test_source_balance_excludes_ratio_seals", + "decorators": [], + "kind": "method", + "name": "test_source_balance_excludes_ratio_seals", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::class:HarmonicsTest", + "qualified_name": "HarmonicsTest.test_source_balance_excludes_ratio_seals", + "signature": "def test_source_balance_excludes_ratio_seals(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 75, + "span": { + "end": { + "byte": 3079, + "column": 43, + "line": 75 + }, + "start": { + "byte": 2377, + "column": 4, + "line": 61 + } + }, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest.test_source_balance_excludes_ratio_seals", + "identity": "HarmonicsTest.test_source_balance_excludes_ratio_seals", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "HarmonicsTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_harmonics.py::class:HarmonicsTest", + "decorators": [], + "kind": "class", + "name": "HarmonicsTest", + "parent_identity": null, + "qualified_name": "HarmonicsTest", + "signature": "class HarmonicsTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4bbe4cc9e1b18bf318fe53af1de4e2b09747dcfd004466842f5aaf9f978b8e17", + "file": "tests/test_harmonics.py", + "location": { + "end_line": 93, + "span": { + "end": { + "byte": 3885, + "column": 35, + "line": 93 + }, + "start": { + "byte": 264, + "column": 0, + "line": 13 + } + }, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_harmonics.py#subject/symbol/HarmonicsTest", + "identity": "HarmonicsTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "importlib.util:importlib.util:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "importlib.util", + "name": "importlib.util" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "file": "tests/test_information_design.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py", + "identity": "tests/test_information_design.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "file": "tests/test_information_design.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py", + "identity": "tests/test_information_design.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "file": "tests/test_information_design.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py", + "identity": "tests/test_information_design.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "file": "tests/test_information_design.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/module/tests%2Ftest_information_design.py", + "identity": "tests/test_information_design.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_blank_redundancy_does_not_pass/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "InformationDesignAuditTests.test_blank_redundancy_does_not_pass", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::method:InformationDesignAuditTests.test_blank_redundancy_does_not_pass", + "decorators": [], + "kind": "method", + "name": "test_blank_redundancy_does_not_pass", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::class:InformationDesignAuditTests", + "qualified_name": "InformationDesignAuditTests.test_blank_redundancy_does_not_pass", + "signature": "def test_blank_redundancy_does_not_pass(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "file": "tests/test_information_design.py", + "location": { + "end_line": 47, + "span": { + "end": { + "byte": 1997, + "column": 86, + "line": 47 + }, + "start": { + "byte": 1396, + "column": 4, + "line": 36 + } + }, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_blank_redundancy_does_not_pass", + "identity": "InformationDesignAuditTests.test_blank_redundancy_does_not_pass", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_color_only_state_fails/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "InformationDesignAuditTests.test_color_only_state_fails", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::method:InformationDesignAuditTests.test_color_only_state_fails", + "decorators": [], + "kind": "method", + "name": "test_color_only_state_fails", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::class:InformationDesignAuditTests", + "qualified_name": "InformationDesignAuditTests.test_color_only_state_fails", + "signature": "def test_color_only_state_fails(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "file": "tests/test_information_design.py", + "location": { + "end_line": 34, + "span": { + "end": { + "byte": 1390, + "column": 86, + "line": 34 + }, + "start": { + "byte": 803, + "column": 4, + "line": 23 + } + }, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_color_only_state_fails", + "identity": "InformationDesignAuditTests.test_color_only_state_fails", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_compound_hue_channels_still_count_as_hue/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "InformationDesignAuditTests.test_compound_hue_channels_still_count_as_hue", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::method:InformationDesignAuditTests.test_compound_hue_channels_still_count_as_hue", + "decorators": [], + "kind": "method", + "name": "test_compound_hue_channels_still_count_as_hue", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::class:InformationDesignAuditTests", + "qualified_name": "InformationDesignAuditTests.test_compound_hue_channels_still_count_as_hue", + "signature": "def test_compound_hue_channels_still_count_as_hue(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "file": "tests/test_information_design.py", + "location": { + "end_line": 73, + "span": { + "end": { + "byte": 3156, + "column": 84, + "line": 73 + }, + "start": { + "byte": 2574, + "column": 4, + "line": 62 + } + }, + "start_line": 62 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_compound_hue_channels_still_count_as_hue", + "identity": "InformationDesignAuditTests.test_compound_hue_channels_still_count_as_hue", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_example_manifest_passes/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "InformationDesignAuditTests.test_example_manifest_passes", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::method:InformationDesignAuditTests.test_example_manifest_passes", + "decorators": [], + "kind": "method", + "name": "test_example_manifest_passes", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::class:InformationDesignAuditTests", + "qualified_name": "InformationDesignAuditTests.test_example_manifest_passes", + "signature": "def test_example_manifest_passes(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "file": "tests/test_information_design.py", + "location": { + "end_line": 21, + "span": { + "end": { + "byte": 797, + "column": 46, + "line": 21 + }, + "start": { + "byte": 540, + "column": 4, + "line": 17 + } + }, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_example_manifest_passes", + "identity": "InformationDesignAuditTests.test_example_manifest_passes", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_hue_cannot_encode_two_independent_dimensions/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "InformationDesignAuditTests.test_hue_cannot_encode_two_independent_dimensions", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::method:InformationDesignAuditTests.test_hue_cannot_encode_two_independent_dimensions", + "decorators": [], + "kind": "method", + "name": "test_hue_cannot_encode_two_independent_dimensions", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::class:InformationDesignAuditTests", + "qualified_name": "InformationDesignAuditTests.test_hue_cannot_encode_two_independent_dimensions", + "signature": "def test_hue_cannot_encode_two_independent_dimensions(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "file": "tests/test_information_design.py", + "location": { + "end_line": 60, + "span": { + "end": { + "byte": 2568, + "column": 84, + "line": 60 + }, + "start": { + "byte": 2003, + "column": 4, + "line": 49 + } + }, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_hue_cannot_encode_two_independent_dimensions", + "identity": "InformationDesignAuditTests.test_hue_cannot_encode_two_independent_dimensions", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_low_contrast_text_fails/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "InformationDesignAuditTests.test_low_contrast_text_fails", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::method:InformationDesignAuditTests.test_low_contrast_text_fails", + "decorators": [], + "kind": "method", + "name": "test_low_contrast_text_fails", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::class:InformationDesignAuditTests", + "qualified_name": "InformationDesignAuditTests.test_low_contrast_text_fails", + "signature": "def test_low_contrast_text_fails(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "file": "tests/test_information_design.py", + "location": { + "end_line": 86, + "span": { + "end": { + "byte": 3757, + "column": 83, + "line": 86 + }, + "start": { + "byte": 3162, + "column": 4, + "line": 75 + } + }, + "start_line": 75 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests.test_low_contrast_text_fails", + "identity": "InformationDesignAuditTests.test_low_contrast_text_fails", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "InformationDesignAuditTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_information_design.py::class:InformationDesignAuditTests", + "decorators": [], + "kind": "class", + "name": "InformationDesignAuditTests", + "parent_identity": null, + "qualified_name": "InformationDesignAuditTests", + "signature": "class InformationDesignAuditTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "0ffcdac0a83dc8a0546bfa0f26a104b13a7e77acc31b556694c8bae7e8f9d86d", + "file": "tests/test_information_design.py", + "location": { + "end_line": 86, + "span": { + "end": { + "byte": 3757, + "column": 83, + "line": 86 + }, + "start": { + "byte": 482, + "column": 0, + "line": 16 + } + }, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_information_design.py#subject/symbol/InformationDesignAuditTests", + "identity": "InformationDesignAuditTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "importlib.util:importlib.util:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "importlib.util", + "name": "importlib.util" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py", + "identity": "tests/test_interdependent_work_graph_portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py", + "identity": "tests/test_interdependent_work_graph_portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py", + "identity": "tests/test_interdependent_work_graph_portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py", + "identity": "tests/test_interdependent_work_graph_portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/module/tests%2Ftest_interdependent_work_graph_portfolio_plan.py", + "identity": "tests/test_interdependent_work_graph_portfolio_plan.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_authority_transfer_is_rejected/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PortfolioPlanTests.test_authority_transfer_is_rejected", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::method:PortfolioPlanTests.test_authority_transfer_is_rejected", + "decorators": [], + "kind": "method", + "name": "test_authority_transfer_is_rejected", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::class:PortfolioPlanTests", + "qualified_name": "PortfolioPlanTests.test_authority_transfer_is_rejected", + "signature": "def test_authority_transfer_is_rejected(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 91, + "span": { + "end": { + "byte": 3892, + "column": 48, + "line": 91 + }, + "start": { + "byte": 3397, + "column": 4, + "line": 84 + } + }, + "start_line": 84 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_authority_transfer_is_rejected", + "identity": "PortfolioPlanTests.test_authority_transfer_is_rejected", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_duplicate_repository_reports_are_rejected/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PortfolioPlanTests.test_duplicate_repository_reports_are_rejected", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::method:PortfolioPlanTests.test_duplicate_repository_reports_are_rejected", + "decorators": [], + "kind": "method", + "name": "test_duplicate_repository_reports_are_rejected", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::class:PortfolioPlanTests", + "qualified_name": "PortfolioPlanTests.test_duplicate_repository_reports_are_rejected", + "signature": "def test_duplicate_repository_reports_are_rejected(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 112, + "span": { + "end": { + "byte": 4992, + "column": 124, + "line": 112 + }, + "start": { + "byte": 4345, + "column": 4, + "line": 102 + } + }, + "start_line": 102 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_duplicate_repository_reports_are_rejected", + "identity": "PortfolioPlanTests.test_duplicate_repository_reports_are_rejected", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_next_action_cannot_override_source_repository/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PortfolioPlanTests.test_next_action_cannot_override_source_repository", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::method:PortfolioPlanTests.test_next_action_cannot_override_source_repository", + "decorators": [], + "kind": "method", + "name": "test_next_action_cannot_override_source_repository", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::class:PortfolioPlanTests", + "qualified_name": "PortfolioPlanTests.test_next_action_cannot_override_source_repository", + "signature": "def test_next_action_cannot_override_source_repository(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 121, + "span": { + "end": { + "byte": 5508, + "column": 48, + "line": 121 + }, + "start": { + "byte": 4998, + "column": 4, + "line": 114 + } + }, + "start_line": 114 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_next_action_cannot_override_source_repository", + "identity": "PortfolioPlanTests.test_next_action_cannot_override_source_repository", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_projection_is_order_independent_and_hashed/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PortfolioPlanTests.test_projection_is_order_independent_and_hashed", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::method:PortfolioPlanTests.test_projection_is_order_independent_and_hashed", + "decorators": [], + "kind": "method", + "name": "test_projection_is_order_independent_and_hashed", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::class:PortfolioPlanTests", + "qualified_name": "PortfolioPlanTests.test_projection_is_order_independent_and_hashed", + "signature": "def test_projection_is_order_independent_and_hashed(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 82, + "span": { + "end": { + "byte": 3391, + "column": 66, + "line": 82 + }, + "start": { + "byte": 2362, + "column": 4, + "line": 65 + } + }, + "start_line": 65 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_projection_is_order_independent_and_hashed", + "identity": "PortfolioPlanTests.test_projection_is_order_independent_and_hashed", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_relation_extras_cannot_override_derived_endpoints/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PortfolioPlanTests.test_relation_extras_cannot_override_derived_endpoints", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::method:PortfolioPlanTests.test_relation_extras_cannot_override_derived_endpoints", + "decorators": [], + "kind": "method", + "name": "test_relation_extras_cannot_override_derived_endpoints", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::class:PortfolioPlanTests", + "qualified_name": "PortfolioPlanTests.test_relation_extras_cannot_override_derived_endpoints", + "signature": "def test_relation_extras_cannot_override_derived_endpoints(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 6407, + "column": 61, + "line": 135 + }, + "start": { + "byte": 5514, + "column": 4, + "line": 123 + } + }, + "start_line": 123 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_relation_extras_cannot_override_derived_endpoints", + "identity": "PortfolioPlanTests.test_relation_extras_cannot_override_derived_endpoints", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_wrong_contract_blob_is_rejected/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PortfolioPlanTests.test_wrong_contract_blob_is_rejected", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::method:PortfolioPlanTests.test_wrong_contract_blob_is_rejected", + "decorators": [], + "kind": "method", + "name": "test_wrong_contract_blob_is_rejected", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::class:PortfolioPlanTests", + "qualified_name": "PortfolioPlanTests.test_wrong_contract_blob_is_rejected", + "signature": "def test_wrong_contract_blob_is_rejected(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 100, + "span": { + "end": { + "byte": 4339, + "column": 48, + "line": 100 + }, + "start": { + "byte": 3898, + "column": 4, + "line": 93 + } + }, + "start_line": 93 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests.test_wrong_contract_blob_is_rejected", + "identity": "PortfolioPlanTests.test_wrong_contract_blob_is_rejected", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "PortfolioPlanTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::class:PortfolioPlanTests", + "decorators": [], + "kind": "class", + "name": "PortfolioPlanTests", + "parent_identity": null, + "qualified_name": "PortfolioPlanTests", + "signature": "class PortfolioPlanTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 6407, + "column": 61, + "line": 135 + }, + "start": { + "byte": 2313, + "column": 0, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/PortfolioPlanTests", + "identity": "PortfolioPlanTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/report/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "report", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_interdependent_work_graph_portfolio_plan.py::function:report", + "decorators": [], + "kind": "function", + "name": "report", + "parent_identity": null, + "qualified_name": "report", + "signature": "def report(repository: str, commit: str, relation_to: str | None=None)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "877b6e4698c2046a9d5cfbbcd94f5d2f62919a93c5dd25a36552aff4ec0e119d", + "file": "tests/test_interdependent_work_graph_portfolio_plan.py", + "location": { + "end_line": 61, + "span": { + "end": { + "byte": 2310, + "column": 5, + "line": 61 + }, + "start": { + "byte": 412, + "column": 0, + "line": 16 + } + }, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_interdependent_work_graph_portfolio_plan.py#subject/symbol/report", + "identity": "report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "identity": "tests/test_llms_build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "identity": "tests/test_llms_build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "identity": "tests/test_llms_build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "identity": "tests/test_llms_build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "llms.build:collect:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "llms.build", + "name": "collect" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "identity": "tests/test_llms_build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "llms.build:generate:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "llms.build", + "name": "generate" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "identity": "tests/test_llms_build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "llms.build:parse_text:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "llms.build", + "name": "parse_text" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/module/tests%2Ftest_llms_build.py", + "identity": "tests/test_llms_build.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest.test_collect_and_generate_from_repo_tree/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "LlmsBuildTest.test_collect_and_generate_from_repo_tree", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_llms_build.py::method:LlmsBuildTest.test_collect_and_generate_from_repo_tree", + "decorators": [], + "kind": "method", + "name": "test_collect_and_generate_from_repo_tree", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_llms_build.py::class:LlmsBuildTest", + "qualified_name": "LlmsBuildTest.test_collect_and_generate_from_repo_tree", + "signature": "def test_collect_and_generate_from_repo_tree(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 91, + "span": { + "end": { + "byte": 3351, + "column": 56, + "line": 91 + }, + "start": { + "byte": 2571, + "column": 4, + "line": 68 + } + }, + "start_line": 68 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest.test_collect_and_generate_from_repo_tree", + "identity": "LlmsBuildTest.test_collect_and_generate_from_repo_tree", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest.test_generate_uses_hmmm_for_missing_sections/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "LlmsBuildTest.test_generate_uses_hmmm_for_missing_sections", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_llms_build.py::method:LlmsBuildTest.test_generate_uses_hmmm_for_missing_sections", + "decorators": [], + "kind": "method", + "name": "test_generate_uses_hmmm_for_missing_sections", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_llms_build.py::class:LlmsBuildTest", + "qualified_name": "LlmsBuildTest.test_generate_uses_hmmm_for_missing_sections", + "signature": "def test_generate_uses_hmmm_for_missing_sections(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 52, + "span": { + "end": { + "byte": 1836, + "column": 84, + "line": 52 + }, + "start": { + "byte": 1390, + "column": 4, + "line": 45 + } + }, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest.test_generate_uses_hmmm_for_missing_sections", + "identity": "LlmsBuildTest.test_generate_uses_hmmm_for_missing_sections", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest.test_markdown_fenced_code_examples_are_ignored/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "LlmsBuildTest.test_markdown_fenced_code_examples_are_ignored", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_llms_build.py::method:LlmsBuildTest.test_markdown_fenced_code_examples_are_ignored", + "decorators": [], + "kind": "method", + "name": "test_markdown_fenced_code_examples_are_ignored", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_llms_build.py::class:LlmsBuildTest", + "qualified_name": "LlmsBuildTest.test_markdown_fenced_code_examples_are_ignored", + "signature": "def test_markdown_fenced_code_examples_are_ignored(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 43, + "span": { + "end": { + "byte": 1384, + "column": 74, + "line": 43 + }, + "start": { + "byte": 926, + "column": 4, + "line": 27 + } + }, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest.test_markdown_fenced_code_examples_are_ignored", + "identity": "LlmsBuildTest.test_markdown_fenced_code_examples_are_ignored", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest.test_native_only_input_retains_uncertainty_and_source_authority/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "LlmsBuildTest.test_native_only_input_retains_uncertainty_and_source_authority", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_llms_build.py::method:LlmsBuildTest.test_native_only_input_retains_uncertainty_and_source_authority", + "decorators": [], + "kind": "method", + "name": "test_native_only_input_retains_uncertainty_and_source_authority", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_llms_build.py::class:LlmsBuildTest", + "qualified_name": "LlmsBuildTest.test_native_only_input_retains_uncertainty_and_source_authority", + "signature": "def test_native_only_input_retains_uncertainty_and_source_authority(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 66, + "span": { + "end": { + "byte": 2565, + "column": 72, + "line": 66 + }, + "start": { + "byte": 1842, + "column": 4, + "line": 54 + } + }, + "start_line": 54 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest.test_native_only_input_retains_uncertainty_and_source_authority", + "identity": "LlmsBuildTest.test_native_only_input_retains_uncertainty_and_source_authority", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest.test_parse_llms_block_allows_hyphenated_key_definitions/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "LlmsBuildTest.test_parse_llms_block_allows_hyphenated_key_definitions", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_llms_build.py::method:LlmsBuildTest.test_parse_llms_block_allows_hyphenated_key_definitions", + "decorators": [], + "kind": "method", + "name": "test_parse_llms_block_allows_hyphenated_key_definitions", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_llms_build.py::class:LlmsBuildTest", + "qualified_name": "LlmsBuildTest.test_parse_llms_block_allows_hyphenated_key_definitions", + "signature": "def test_parse_llms_block_allows_hyphenated_key_definitions(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 25, + "span": { + "end": { + "byte": 920, + "column": 85, + "line": 25 + }, + "start": { + "byte": 193, + "column": 4, + "line": 11 + } + }, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest.test_parse_llms_block_allows_hyphenated_key_definitions", + "identity": "LlmsBuildTest.test_parse_llms_block_allows_hyphenated_key_definitions", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "LlmsBuildTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_llms_build.py::class:LlmsBuildTest", + "decorators": [], + "kind": "class", + "name": "LlmsBuildTest", + "parent_identity": null, + "qualified_name": "LlmsBuildTest", + "signature": "class LlmsBuildTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fb54919054fede0c1e530c31c1d1ade149442013f6dd9522298d1f10faa67d10", + "file": "tests/test_llms_build.py", + "location": { + "end_line": 91, + "span": { + "end": { + "byte": 3351, + "column": 56, + "line": 91 + }, + "start": { + "byte": 149, + "column": 0, + "line": 10 + } + }, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_llms_build.py#subject/symbol/LlmsBuildTest", + "identity": "LlmsBuildTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "334:42" + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A905-905/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "334:42" + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 905, + "start_line": 905 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "9:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A905-905/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "9:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 905, + "start_line": 905 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "97:713" + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A905-905/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "97:713" + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 905, + "start_line": 905 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=97:713 imports_exports=9:11 calls_definitions=334:42" + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 75, + "column": 75, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CHECKS ===\nid: check_module_projection_line_shift_stability\n proves: module_projection_line_shift_stability\n call: self::test_line_insertions_preserve_symbol_identity_and_attachment\n requires: python3\n timeout: 10\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_module_projection_never_executes_source\n proves: module_projection_never_executes_source\n call: self::test_projection_does_not_execute_inspected_source\n requires: python3\n timeout: 10\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_module_projection_freshness_binds_source_and_reader\n proves: module_projection_freshness_binds_source_and_reader\n call: self::test_freshness_key_changes_with_source_or_reader\n requires: python3\n timeout: 10\n mutates: filesystem\n cleanup: tempdir_teardown\n=== END CHECKS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 26, + "span": { + "end": { + "byte": 935, + "column": 20, + "line": 26 + }, + "start": { + "byte": 76, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=97:713 imports_exports=9:11 calls_definitions=334:42" + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 905, + "span": { + "end": { + "byte": 38040, + "column": 75, + "line": 905 + }, + "start": { + "byte": 37965, + "column": 0, + "line": 905 + } + }, + "start_line": 905 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::<module>", + "description": "Usage: ``python -m unittest tests.test_module_projection``.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Tests for deterministic Python module metadata projections.", + "text": "Tests for deterministic Python module metadata projections.\n\nUsage: ``python -m unittest tests.test_module_projection``.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 30, + "span": { + "end": { + "byte": 1063, + "column": 3, + "line": 30 + }, + "start": { + "byte": 936, + "column": 0, + "line": 27 + } + }, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 31, + "start_line": 31 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "ast:ast:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "ast", + "name": "ast" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 33, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.module_projection:check_projections:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.module_projection", + "name": "check_projections" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 49, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.module_projection:project_python_module:11", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.module_projection", + "name": "project_python_module" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 49, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/12", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.module_projection:project_tree:12", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.module_projection", + "name": "project_tree" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 49, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/13", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.module_projection:render_jsonl:13", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.module_projection", + "name": "render_jsonl" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 49, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/14", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.module_projection:write_projections:14", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.module_projection", + "name": "write_projections" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 49, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 34, + "start_line": 34 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 35, + "start_line": 35 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 36, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 37, + "start_line": 37 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:6", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 38, + "start_line": 38 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:mock:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "unittest", + "name": "mock" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 39, + "start_line": 39 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.module_projection:SCHEMA_ID:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.module_projection", + "name": "SCHEMA_ID" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 49, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.module_projection:_signature:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.module_projection", + "name": "_signature" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 49, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/module/tests%2Ftest_module_projection.py", + "identity": "tests/test_module_projection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_corrupt_non_utf8_sidecar_is_stale_and_repairable/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_corrupt_non_utf8_sidecar_is_stale_and_repairable", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_corrupt_non_utf8_sidecar_is_stale_and_repairable", + "decorators": [], + "kind": "method", + "name": "test_corrupt_non_utf8_sidecar_is_stale_and_repairable", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_corrupt_non_utf8_sidecar_is_stale_and_repairable", + "signature": "def test_corrupt_non_utf8_sidecar_is_stale_and_repairable(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 487, + "span": { + "end": { + "byte": 18475, + "column": 98, + "line": 487 + }, + "start": { + "byte": 17700, + "column": 4, + "line": 472 + } + }, + "start_line": 472 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_corrupt_non_utf8_sidecar_is_stale_and_repairable", + "identity": "ModuleProjectionTests.test_corrupt_non_utf8_sidecar_is_stale_and_repairable", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "metadata_kind": "comment", + "text": "Python honors a coding cookie on line 1 or 2 only; CR-only line\nendings must be split before encoding detection." + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 826, + "span": { + "end": { + "byte": 34307, + "column": 62, + "line": 826 + }, + "start": { + "byte": 34179, + "column": 12, + "line": 825 + } + }, + "start_line": 825 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "identity": "ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "metadata_kind": "comment", + "text": "CPython's own compiler is the oracle (compile does not execute)." + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 858, + "span": { + "end": { + "byte": 35497, + "column": 82, + "line": 858 + }, + "start": { + "byte": 35431, + "column": 16, + "line": 858 + } + }, + "start_line": 858 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "identity": "ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "decorators": [], + "kind": "method", + "name": "test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "signature": "def test_cr_only_latin1_encoding_cookie_follows_python_line_rules(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 877, + "span": { + "end": { + "byte": 36624, + "column": 67, + "line": 877 + }, + "start": { + "byte": 34068, + "column": 4, + "line": 823 + } + }, + "start_line": 823 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "identity": "ModuleProjectionTests.test_cr_only_latin1_encoding_cookie_follows_python_line_rules", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_cr_only_source_keeps_offsets_attachment_and_convergence/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_cr_only_source_keeps_offsets_attachment_and_convergence", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_cr_only_source_keeps_offsets_attachment_and_convergence", + "decorators": [], + "kind": "method", + "name": "test_cr_only_source_keeps_offsets_attachment_and_convergence", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_cr_only_source_keeps_offsets_attachment_and_convergence", + "signature": "def test_cr_only_source_keeps_offsets_attachment_and_convergence(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 821, + "span": { + "end": { + "byte": 34062, + "column": 92, + "line": 821 + }, + "start": { + "byte": 31239, + "column": 4, + "line": 768 + } + }, + "start_line": 768 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_cr_only_source_keeps_offsets_attachment_and_convergence", + "identity": "ModuleProjectionTests.test_cr_only_source_keeps_offsets_attachment_and_convergence", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_decorator_and_method_leading_comments_attach_to_the_declaration/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_decorator_and_method_leading_comments_attach_to_the_declaration", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_decorator_and_method_leading_comments_attach_to_the_declaration", + "decorators": [], + "kind": "method", + "name": "test_decorator_and_method_leading_comments_attach_to_the_declaration", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_decorator_and_method_leading_comments_attach_to_the_declaration", + "signature": "def test_decorator_and_method_leading_comments_attach_to_the_declaration(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 185, + "span": { + "end": { + "byte": 6036, + "column": 74, + "line": 185 + }, + "start": { + "byte": 4915, + "column": 4, + "line": 154 + } + }, + "start_line": 154 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_decorator_and_method_leading_comments_attach_to_the_declaration", + "identity": "ModuleProjectionTests.test_decorator_and_method_leading_comments_attach_to_the_declaration", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_decorator_region_comments_attach_to_the_decorated_symbol/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_decorator_region_comments_attach_to_the_decorated_symbol", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_decorator_region_comments_attach_to_the_decorated_symbol", + "decorators": [], + "kind": "method", + "name": "test_decorator_region_comments_attach_to_the_decorated_symbol", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_decorator_region_comments_attach_to_the_decorated_symbol", + "signature": "def test_decorator_region_comments_attach_to_the_decorated_symbol(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 654, + "span": { + "end": { + "byte": 25433, + "column": 13, + "line": 654 + }, + "start": { + "byte": 23628, + "column": 4, + "line": 598 + } + }, + "start_line": 598 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_decorator_region_comments_attach_to_the_decorated_symbol", + "identity": "ModuleProjectionTests.test_decorator_region_comments_attach_to_the_decorated_symbol", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_definitions_inside_control_flow_keep_their_lexical_owner/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_definitions_inside_control_flow_keep_their_lexical_owner", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_definitions_inside_control_flow_keep_their_lexical_owner", + "decorators": [], + "kind": "method", + "name": "test_definitions_inside_control_flow_keep_their_lexical_owner", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_definitions_inside_control_flow_keep_their_lexical_owner", + "signature": "def test_definitions_inside_control_flow_keep_their_lexical_owner(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 215, + "span": { + "end": { + "byte": 7040, + "column": 13, + "line": 215 + }, + "start": { + "byte": 6042, + "column": 4, + "line": 187 + } + }, + "start_line": 187 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_definitions_inside_control_flow_keep_their_lexical_owner", + "identity": "ModuleProjectionTests.test_definitions_inside_control_flow_keep_their_lexical_owner", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_definitions_inside_match_cases_and_except_handlers_are_discovered/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_definitions_inside_match_cases_and_except_handlers_are_discovered", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_definitions_inside_match_cases_and_except_handlers_are_discovered", + "decorators": [], + "kind": "method", + "name": "test_definitions_inside_match_cases_and_except_handlers_are_discovered", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_definitions_inside_match_cases_and_except_handlers_are_discovered", + "signature": "def test_definitions_inside_match_cases_and_except_handlers_are_discovered(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 252, + "span": { + "end": { + "byte": 8235, + "column": 13, + "line": 252 + }, + "start": { + "byte": 7046, + "column": 4, + "line": 217 + } + }, + "start_line": 217 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_definitions_inside_match_cases_and_except_handlers_are_discovered", + "identity": "ModuleProjectionTests.test_definitions_inside_match_cases_and_except_handlers_are_discovered", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_freshness_key_changes_with_source_or_reader/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_freshness_key_changes_with_source_or_reader", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_freshness_key_changes_with_source_or_reader", + "decorators": [], + "kind": "method", + "name": "test_freshness_key_changes_with_source_or_reader", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_freshness_key_changes_with_source_or_reader", + "signature": "def test_freshness_key_changes_with_source_or_reader(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 450, + "span": { + "end": { + "byte": 16634, + "column": 13, + "line": 450 + }, + "start": { + "byte": 13860, + "column": 4, + "line": 398 + } + }, + "start_line": 398 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_freshness_key_changes_with_source_or_reader", + "identity": "ModuleProjectionTests.test_freshness_key_changes_with_source_or_reader", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_generic_type_parameters_are_rendered_in_signatures/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_generic_type_parameters_are_rendered_in_signatures", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_generic_type_parameters_are_rendered_in_signatures", + "decorators": [], + "kind": "method", + "name": "test_generic_type_parameters_are_rendered_in_signatures", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_generic_type_parameters_are_rendered_in_signatures", + "signature": "def test_generic_type_parameters_are_rendered_in_signatures(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 378, + "span": { + "end": { + "byte": 13167, + "column": 70, + "line": 378 + }, + "start": { + "byte": 12681, + "column": 4, + "line": 371 + } + }, + "start_line": 371 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_generic_type_parameters_are_rendered_in_signatures", + "identity": "ModuleProjectionTests.test_generic_type_parameters_are_rendered_in_signatures", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_interrupted_and_unclosed_msdmd_fences_emit_diagnostics/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_interrupted_and_unclosed_msdmd_fences_emit_diagnostics", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_interrupted_and_unclosed_msdmd_fences_emit_diagnostics", + "decorators": [], + "kind": "method", + "name": "test_interrupted_and_unclosed_msdmd_fences_emit_diagnostics", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_interrupted_and_unclosed_msdmd_fences_emit_diagnostics", + "signature": "def test_interrupted_and_unclosed_msdmd_fences_emit_diagnostics(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 340, + "span": { + "end": { + "byte": 11628, + "column": 17, + "line": 340 + }, + "start": { + "byte": 10181, + "column": 4, + "line": 308 + } + }, + "start_line": 308 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_interrupted_and_unclosed_msdmd_fences_emit_diagnostics", + "identity": "ModuleProjectionTests.test_interrupted_and_unclosed_msdmd_fences_emit_diagnostics", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_invalid_python_is_visible_and_fails_freshness_check/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_invalid_python_is_visible_and_fails_freshness_check", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_invalid_python_is_visible_and_fails_freshness_check", + "decorators": [], + "kind": "method", + "name": "test_invalid_python_is_visible_and_fails_freshness_check", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_invalid_python_is_visible_and_fails_freshness_check", + "signature": "def test_invalid_python_is_visible_and_fails_freshness_check(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 555, + "span": { + "end": { + "byte": 21636, + "column": 13, + "line": 555 + }, + "start": { + "byte": 20810, + "column": 4, + "line": 538 + } + }, + "start_line": 538 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_invalid_python_is_visible_and_fails_freshness_check", + "identity": "ModuleProjectionTests.test_invalid_python_is_visible_and_fails_freshness_check", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_line_insertions_preserve_symbol_identity_and_attachment/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_line_insertions_preserve_symbol_identity_and_attachment", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_line_insertions_preserve_symbol_identity_and_attachment", + "decorators": [], + "kind": "method", + "name": "test_line_insertions_preserve_symbol_identity_and_attachment", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_line_insertions_preserve_symbol_identity_and_attachment", + "signature": "def test_line_insertions_preserve_symbol_identity_and_attachment(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 152, + "span": { + "end": { + "byte": 4909, + "column": 13, + "line": 152 + }, + "start": { + "byte": 3590, + "column": 4, + "line": 121 + } + }, + "start_line": 121 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_line_insertions_preserve_symbol_identity_and_attachment", + "identity": "ModuleProjectionTests.test_line_insertions_preserve_symbol_identity_and_attachment", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate", + "metadata_kind": "comment", + "text": "A mismatch yields exactly one diagnostic: closes orphaned by an\nalready-diagnosed mismatch are suppressed until the next opening of\nthat name, while any other orphan close is still reported." + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 659, + "span": { + "end": { + "byte": 25739, + "column": 68, + "line": 659 + }, + "start": { + "byte": 25527, + "column": 8, + "line": 657 + } + }, + "start_line": 657 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate", + "identity": "ModuleProjectionTests.test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate", + "decorators": [], + "kind": "method", + "name": "test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate", + "signature": "def test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 732, + "span": { + "end": { + "byte": 29379, + "column": 94, + "line": 732 + }, + "start": { + "byte": 25439, + "column": 4, + "line": 656 + } + }, + "start_line": 656 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate", + "identity": "ModuleProjectionTests.test_mismatched_msdmd_fences_emit_diagnostics_and_invalidate", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_only_python_recognized_encoding_cookie_is_module_metadata/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_only_python_recognized_encoding_cookie_is_module_metadata", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_only_python_recognized_encoding_cookie_is_module_metadata", + "decorators": [], + "kind": "method", + "name": "test_only_python_recognized_encoding_cookie_is_module_metadata", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_only_python_recognized_encoding_cookie_is_module_metadata", + "signature": "def test_only_python_recognized_encoding_cookie_is_module_metadata(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 369, + "span": { + "end": { + "byte": 12675, + "column": 13, + "line": 369 + }, + "start": { + "byte": 11634, + "column": 4, + "line": 342 + } + }, + "start_line": 342 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_only_python_recognized_encoding_cookie_is_module_metadata", + "identity": "ModuleProjectionTests.test_only_python_recognized_encoding_cookie_is_module_metadata", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_projection_does_not_execute_inspected_source/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_projection_does_not_execute_inspected_source", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_projection_does_not_execute_inspected_source", + "decorators": [], + "kind": "method", + "name": "test_projection_does_not_execute_inspected_source", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_projection_does_not_execute_inspected_source", + "signature": "def test_projection_does_not_execute_inspected_source(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 396, + "span": { + "end": { + "byte": 13854, + "column": 45, + "line": 396 + }, + "start": { + "byte": 13173, + "column": 4, + "line": 380 + } + }, + "start_line": 380 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_projection_does_not_execute_inspected_source", + "identity": "ModuleProjectionTests.test_projection_does_not_execute_inspected_source", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_projection_paths_cannot_escape_the_output_directory/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_projection_paths_cannot_escape_the_output_directory", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_projection_paths_cannot_escape_the_output_directory", + "decorators": [], + "kind": "method", + "name": "test_projection_paths_cannot_escape_the_output_directory", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_projection_paths_cannot_escape_the_output_directory", + "signature": "def test_projection_paths_cannot_escape_the_output_directory(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 520, + "span": { + "end": { + "byte": 20097, + "column": 74, + "line": 520 + }, + "start": { + "byte": 19526, + "column": 4, + "line": 511 + } + }, + "start_line": 511 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_projection_paths_cannot_escape_the_output_directory", + "identity": "ModuleProjectionTests.test_projection_paths_cannot_escape_the_output_directory", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_projection_schema_declares_all_record_types/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_projection_schema_declares_all_record_types", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_projection_schema_declares_all_record_types", + "decorators": [], + "kind": "method", + "name": "test_projection_schema_declares_all_record_types", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_projection_schema_declares_all_record_types", + "signature": "def test_projection_schema_declares_all_record_types(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 886, + "span": { + "end": { + "byte": 37098, + "column": 9, + "line": 886 + }, + "start": { + "byte": 36630, + "column": 4, + "line": 879 + } + }, + "start_line": 879 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_projection_schema_declares_all_record_types", + "identity": "ModuleProjectionTests.test_projection_schema_declares_all_record_types", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_reader_manifest_discloses_the_partial_supported_subset/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_reader_manifest_discloses_the_partial_supported_subset", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_reader_manifest_discloses_the_partial_supported_subset", + "decorators": [], + "kind": "method", + "name": "test_reader_manifest_discloses_the_partial_supported_subset", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_reader_manifest_discloses_the_partial_supported_subset", + "signature": "def test_reader_manifest_discloses_the_partial_supported_subset(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 900, + "span": { + "end": { + "byte": 37915, + "column": 71, + "line": 900 + }, + "start": { + "byte": 37104, + "column": 4, + "line": 888 + } + }, + "start_line": 888 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_reader_manifest_discloses_the_partial_supported_subset", + "identity": "ModuleProjectionTests.test_reader_manifest_discloses_the_partial_supported_subset", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_render_and_freshness_check_are_deterministic/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_render_and_freshness_check_are_deterministic", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_render_and_freshness_check_are_deterministic", + "decorators": [], + "kind": "method", + "name": "test_render_and_freshness_check_are_deterministic", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_render_and_freshness_check_are_deterministic", + "signature": "def test_render_and_freshness_check_are_deterministic(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 470, + "span": { + "end": { + "byte": 17694, + "column": 87, + "line": 470 + }, + "start": { + "byte": 16640, + "column": 4, + "line": 452 + } + }, + "start_line": 452 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_render_and_freshness_check_are_deterministic", + "identity": "ModuleProjectionTests.test_render_and_freshness_check_are_deterministic", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_selected_write_and_check_do_not_prune_or_reject_other_modules/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_selected_write_and_check_do_not_prune_or_reject_other_modules", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_selected_write_and_check_do_not_prune_or_reject_other_modules", + "decorators": [], + "kind": "method", + "name": "test_selected_write_and_check_do_not_prune_or_reject_other_modules", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_selected_write_and_check_do_not_prune_or_reject_other_modules", + "signature": "def test_selected_write_and_check_do_not_prune_or_reject_other_modules(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 509, + "span": { + "end": { + "byte": 19520, + "column": 13, + "line": 509 + }, + "start": { + "byte": 18481, + "column": 4, + "line": 489 + } + }, + "start_line": 489 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_selected_write_and_check_do_not_prune_or_reject_other_modules", + "identity": "ModuleProjectionTests.test_selected_write_and_check_do_not_prune_or_reject_other_modules", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_special_file_conventions_remain_module_scoped/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_special_file_conventions_remain_module_scoped", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_special_file_conventions_remain_module_scoped", + "decorators": [], + "kind": "method", + "name": "test_special_file_conventions_remain_module_scoped", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_special_file_conventions_remain_module_scoped", + "signature": "def test_special_file_conventions_remain_module_scoped(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 306, + "span": { + "end": { + "byte": 10175, + "column": 99, + "line": 306 + }, + "start": { + "byte": 9098, + "column": 4, + "line": 281 + } + }, + "start_line": 281 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_special_file_conventions_remain_module_scoped", + "identity": "ModuleProjectionTests.test_special_file_conventions_remain_module_scoped", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_structural_comment_attachment_uses_leading_and_enclosing_owners/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_structural_comment_attachment_uses_leading_and_enclosing_owners", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_structural_comment_attachment_uses_leading_and_enclosing_owners", + "decorators": [], + "kind": "method", + "name": "test_structural_comment_attachment_uses_leading_and_enclosing_owners", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_structural_comment_attachment_uses_leading_and_enclosing_owners", + "signature": "def test_structural_comment_attachment_uses_leading_and_enclosing_owners(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 119, + "span": { + "end": { + "byte": 3584, + "column": 13, + "line": 119 + }, + "start": { + "byte": 1894, + "column": 4, + "line": 69 + } + }, + "start_line": 69 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_structural_comment_attachment_uses_leading_and_enclosing_owners", + "identity": "ModuleProjectionTests.test_structural_comment_attachment_uses_leading_and_enclosing_owners", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_trailing_suite_comments_remain_on_the_lexical_owner/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_trailing_suite_comments_remain_on_the_lexical_owner", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_trailing_suite_comments_remain_on_the_lexical_owner", + "decorators": [], + "kind": "method", + "name": "test_trailing_suite_comments_remain_on_the_lexical_owner", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_trailing_suite_comments_remain_on_the_lexical_owner", + "signature": "def test_trailing_suite_comments_remain_on_the_lexical_owner(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 279, + "span": { + "end": { + "byte": 9092, + "column": 13, + "line": 279 + }, + "start": { + "byte": 8241, + "column": 4, + "line": 254 + } + }, + "start_line": 254 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_trailing_suite_comments_remain_on_the_lexical_owner", + "identity": "ModuleProjectionTests.test_trailing_suite_comments_remain_on_the_lexical_owner", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_unicode_ast_columns_are_normalized_to_character_and_byte_offsets/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_unicode_ast_columns_are_normalized_to_character_and_byte_offsets", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_unicode_ast_columns_are_normalized_to_character_and_byte_offsets", + "decorators": [], + "kind": "method", + "name": "test_unicode_ast_columns_are_normalized_to_character_and_byte_offsets", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_unicode_ast_columns_are_normalized_to_character_and_byte_offsets", + "signature": "def test_unicode_ast_columns_are_normalized_to_character_and_byte_offsets(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 536, + "span": { + "end": { + "byte": 20804, + "column": 71, + "line": 536 + }, + "start": { + "byte": 20103, + "column": 4, + "line": 522 + } + }, + "start_line": 522 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_unicode_ast_columns_are_normalized_to_character_and_byte_offsets", + "identity": "ModuleProjectionTests.test_unicode_ast_columns_are_normalized_to_character_and_byte_offsets", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_unicode_line_separators_do_not_split_python_source_lines/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_unicode_line_separators_do_not_split_python_source_lines", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_unicode_line_separators_do_not_split_python_source_lines", + "decorators": [], + "kind": "method", + "name": "test_unicode_line_separators_do_not_split_python_source_lines", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_unicode_line_separators_do_not_split_python_source_lines", + "signature": "def test_unicode_line_separators_do_not_split_python_source_lines(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 766, + "span": { + "end": { + "byte": 31233, + "column": 69, + "line": 766 + }, + "start": { + "byte": 29385, + "column": 4, + "line": 734 + } + }, + "start_line": 734 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_unicode_line_separators_do_not_split_python_source_lines", + "identity": "ModuleProjectionTests.test_unicode_line_separators_do_not_split_python_source_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars.windows_text_translation/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::function:ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars.windows_text_translation", + "metadata_kind": "comment", + "text": "Simulate Windows text-mode newline translation: any text-mode\nwriter that does not disable translation emits CRLF." + } + }, + "origin": "native", + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 572, + "span": { + "end": { + "byte": 22436, + "column": 70, + "line": 572 + }, + "start": { + "byte": 22302, + "column": 16, + "line": 571 + } + }, + "start_line": 571 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars.windows_text_translation", + "identity": "ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars.windows_text_translation", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars.windows_text_translation/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars.windows_text_translation", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::function:ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars.windows_text_translation", + "decorators": [], + "kind": "function", + "name": "windows_text_translation", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars", + "qualified_name": "ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars.windows_text_translation", + "signature": "def windows_text_translation(*args, **kwargs)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 576, + "span": { + "end": { + "byte": 22689, + "column": 65, + "line": 576 + }, + "start": { + "byte": 22239, + "column": 12, + "line": 570 + } + }, + "start_line": 570 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars.windows_text_translation", + "identity": "ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars.windows_text_translation", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::method:ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars", + "decorators": [], + "kind": "method", + "name": "test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "qualified_name": "ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars", + "signature": "def test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 596, + "span": { + "end": { + "byte": 23622, + "column": 69, + "line": 596 + }, + "start": { + "byte": 21642, + "column": 4, + "line": 557 + } + }, + "start_line": 557 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars", + "identity": "ModuleProjectionTests.test_write_emits_exact_lf_utf8_bytes_and_repairs_crlf_sidecars", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "ModuleProjectionTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::class:ModuleProjectionTests", + "decorators": [], + "kind": "class", + "name": "ModuleProjectionTests", + "parent_identity": null, + "qualified_name": "ModuleProjectionTests", + "signature": "class ModuleProjectionTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 900, + "span": { + "end": { + "byte": 37915, + "column": 71, + "line": 900 + }, + "start": { + "byte": 1842, + "column": 0, + "line": 68 + } + }, + "start_line": 68 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/ModuleProjectionTests", + "identity": "ModuleProjectionTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/_metadata_subjects/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_metadata_subjects", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::function:_metadata_subjects", + "decorators": [], + "kind": "function", + "name": "_metadata_subjects", + "parent_identity": null, + "qualified_name": "_metadata_subjects", + "signature": "def _metadata_subjects(records: list[dict]) -> dict[str, tuple[str, str]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 57, + "span": { + "end": { + "byte": 1640, + "column": 5, + "line": 57 + }, + "start": { + "byte": 1404, + "column": 0, + "line": 52 + } + }, + "start_line": 52 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/_metadata_subjects", + "identity": "_metadata_subjects", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/_symbol_ids/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_symbol_ids", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_module_projection.py::function:_symbol_ids", + "decorators": [], + "kind": "function", + "name": "_symbol_ids", + "parent_identity": null, + "qualified_name": "_symbol_ids", + "signature": "def _symbol_ids(records: list[dict]) -> dict[str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ead4ae4a092972f3c9eb5138900e131ba324299af4a3d1cd9fed896750d90403", + "file": "tests/test_module_projection.py", + "location": { + "end_line": 65, + "span": { + "end": { + "byte": 1839, + "column": 5, + "line": 65 + }, + "start": { + "byte": 1643, + "column": 0, + "line": 60 + } + }, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_module_projection.py#subject/symbol/_symbol_ids", + "identity": "_symbol_ids", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::<module>", + "description": "Usage: python -m unittest discover -s tests -p 'test_msdmd_native_contract_docs.py'\nThe complete repository suite and generated-file gates remain separate checks.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Regression checks for native-first contracts and bounded reader disclosure.", + "text": "Regression checks for native-first contracts and bounded reader disclosure.\n\nUsage: python -m unittest discover -s tests -p 'test_msdmd_native_contract_docs.py'\nThe complete repository suite and generated-file gates remain separate checks.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 5, + "span": { + "end": { + "byte": 246, + "column": 3, + "line": 5 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.build_codex_plugin_skills:canonical_frontmatter:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.build_codex_plugin_skills", + "name": "canonical_frontmatter" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "llms:build:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "llms", + "name": "build" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collect:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collect" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:render_typescript:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "render_typescript" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:parse_file:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "parse_file" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.visualize:load_collection:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.visualize", + "name": "load_collection" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.build_codex_plugin_skills:adapter:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.build_codex_plugin_skills", + "name": "adapter" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/module/tests%2Ftest_msdmd_native_contract_docs.py", + "identity": "tests/test_msdmd_native_contract_docs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeContractDocsTests.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::method:NativeContractDocsTests.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::class:NativeContractDocsTests", + "qualified_name": "NativeContractDocsTests.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 28, + "span": { + "end": { + "byte": 1018, + "column": 76, + "line": 28 + }, + "start": { + "byte": 833, + "column": 4, + "line": 26 + } + }, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.setUp", + "identity": "NativeContractDocsTests.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_application_contracts_and_discovery_are_native_first/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeContractDocsTests.test_application_contracts_and_discovery_are_native_first", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::method:NativeContractDocsTests.test_application_contracts_and_discovery_are_native_first", + "decorators": [], + "kind": "method", + "name": "test_application_contracts_and_discovery_are_native_first", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::class:NativeContractDocsTests", + "qualified_name": "NativeContractDocsTests.test_application_contracts_and_discovery_are_native_first", + "signature": "def test_application_contracts_and_discovery_are_native_first(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 45, + "span": { + "end": { + "byte": 1869, + "column": 17, + "line": 45 + }, + "start": { + "byte": 1024, + "column": 4, + "line": 30 + } + }, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_application_contracts_and_discovery_are_native_first", + "identity": "NativeContractDocsTests.test_application_contracts_and_discovery_are_native_first", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_helper_identity_and_extraction_limits_are_explicit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeContractDocsTests.test_helper_identity_and_extraction_limits_are_explicit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::method:NativeContractDocsTests.test_helper_identity_and_extraction_limits_are_explicit", + "decorators": [], + "kind": "method", + "name": "test_helper_identity_and_extraction_limits_are_explicit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::class:NativeContractDocsTests", + "qualified_name": "NativeContractDocsTests.test_helper_identity_and_extraction_limits_are_explicit", + "signature": "def test_helper_identity_and_extraction_limits_are_explicit(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 92, + "span": { + "end": { + "byte": 4537, + "column": 85, + "line": 92 + }, + "start": { + "byte": 3994, + "column": 4, + "line": 86 + } + }, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_helper_identity_and_extraction_limits_are_explicit", + "identity": "NativeContractDocsTests.test_helper_identity_and_extraction_limits_are_explicit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_llm_publication_matches_owning_sources/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeContractDocsTests.test_llm_publication_matches_owning_sources", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::method:NativeContractDocsTests.test_llm_publication_matches_owning_sources", + "decorators": [], + "kind": "method", + "name": "test_llm_publication_matches_owning_sources", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::class:NativeContractDocsTests", + "qualified_name": "NativeContractDocsTests.test_llm_publication_matches_owning_sources", + "signature": "def test_llm_publication_matches_owning_sources(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 103, + "span": { + "end": { + "byte": 5306, + "column": 84, + "line": 103 + }, + "start": { + "byte": 4543, + "column": 4, + "line": 94 + } + }, + "start_line": 94 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_llm_publication_matches_owning_sources", + "identity": "NativeContractDocsTests.test_llm_publication_matches_owning_sources", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_native_ingestion_preserves_evidence_and_authority_boundaries/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeContractDocsTests.test_native_ingestion_preserves_evidence_and_authority_boundaries", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::method:NativeContractDocsTests.test_native_ingestion_preserves_evidence_and_authority_boundaries", + "decorators": [], + "kind": "method", + "name": "test_native_ingestion_preserves_evidence_and_authority_boundaries", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::class:NativeContractDocsTests", + "qualified_name": "NativeContractDocsTests.test_native_ingestion_preserves_evidence_and_authority_boundaries", + "signature": "def test_native_ingestion_preserves_evidence_and_authority_boundaries(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 116, + "span": { + "end": { + "byte": 6001, + "column": 64, + "line": 116 + }, + "start": { + "byte": 5312, + "column": 4, + "line": 105 + } + }, + "start_line": 105 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_native_ingestion_preserves_evidence_and_authority_boundaries", + "identity": "NativeContractDocsTests.test_native_ingestion_preserves_evidence_and_authority_boundaries", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_native_runner_and_shared_python_reader_have_explicit_scopes/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeContractDocsTests.test_native_runner_and_shared_python_reader_have_explicit_scopes", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::method:NativeContractDocsTests.test_native_runner_and_shared_python_reader_have_explicit_scopes", + "decorators": [], + "kind": "method", + "name": "test_native_runner_and_shared_python_reader_have_explicit_scopes", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::class:NativeContractDocsTests", + "qualified_name": "NativeContractDocsTests.test_native_runner_and_shared_python_reader_have_explicit_scopes", + "signature": "def test_native_runner_and_shared_python_reader_have_explicit_scopes(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 84, + "span": { + "end": { + "byte": 3988, + "column": 90, + "line": 84 + }, + "start": { + "byte": 3419, + "column": 4, + "line": 77 + } + }, + "start_line": 77 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_native_runner_and_shared_python_reader_have_explicit_scopes", + "identity": "NativeContractDocsTests.test_native_runner_and_shared_python_reader_have_explicit_scopes", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_repository_collection_replays_from_owning_blocks/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeContractDocsTests.test_repository_collection_replays_from_owning_blocks", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::method:NativeContractDocsTests.test_repository_collection_replays_from_owning_blocks", + "decorators": [], + "kind": "method", + "name": "test_repository_collection_replays_from_owning_blocks", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::class:NativeContractDocsTests", + "qualified_name": "NativeContractDocsTests.test_repository_collection_replays_from_owning_blocks", + "signature": "def test_repository_collection_replays_from_owning_blocks(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 143, + "span": { + "end": { + "byte": 7236, + "column": 48, + "line": 143 + }, + "start": { + "byte": 6007, + "column": 4, + "line": 118 + } + }, + "start_line": 118 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_repository_collection_replays_from_owning_blocks", + "identity": "NativeContractDocsTests.test_repository_collection_replays_from_owning_blocks", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_retired_block_absence_rules_are_removed/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeContractDocsTests.test_retired_block_absence_rules_are_removed", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::method:NativeContractDocsTests.test_retired_block_absence_rules_are_removed", + "decorators": [], + "kind": "method", + "name": "test_retired_block_absence_rules_are_removed", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::class:NativeContractDocsTests", + "qualified_name": "NativeContractDocsTests.test_retired_block_absence_rules_are_removed", + "signature": "def test_retired_block_absence_rules_are_removed(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 75, + "span": { + "end": { + "byte": 3413, + "column": 50, + "line": 75 + }, + "start": { + "byte": 1875, + "column": 4, + "line": 47 + } + }, + "start_line": 47 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests.test_retired_block_absence_rules_are_removed", + "identity": "NativeContractDocsTests.test_retired_block_absence_rules_are_removed", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "NativeContractDocsTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_msdmd_native_contract_docs.py::class:NativeContractDocsTests", + "decorators": [], + "kind": "class", + "name": "NativeContractDocsTests", + "parent_identity": null, + "qualified_name": "NativeContractDocsTests", + "signature": "class NativeContractDocsTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d8b49520be5c780e2f2a04965b1905358256b12e813e76219e646be8c5dabc6d", + "file": "tests/test_msdmd_native_contract_docs.py", + "location": { + "end_line": 143, + "span": { + "end": { + "byte": 7236, + "column": 48, + "line": 143 + }, + "start": { + "byte": 779, + "column": 0, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_msdmd_native_contract_docs.py#subject/symbol/NativeContractDocsTests", + "identity": "NativeContractDocsTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::<module>", + "description": "Usage: python -m unittest tests.test_native_collection\nThese tests exercise static extraction only; they never execute fixture code.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Executable acceptance fixtures for the MSDMD native collection contract.", + "text": "Executable acceptance fixtures for the MSDMD native collection contract.\n\nUsage: python -m unittest tests.test_native_collection\nThese tests exercise static extraction only; they never execute fixture code.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 5, + "span": { + "end": { + "byte": 213, + "column": 3, + "line": 5 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "identity": "tests/test_native_collection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "identity": "tests/test_native_collection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "identity": "tests/test_native_collection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "identity": "tests/test_native_collection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "identity": "tests/test_native_collection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "identity": "tests/test_native_collection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "identity": "tests/test_native_collection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:SCHEMA_VERSION:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "SCHEMA_VERSION" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "identity": "tests/test_native_collection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collect:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collect" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "identity": "tests/test_native_collection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collection_errors:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collection_errors" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/module/tests%2Ftest_native_collection.py", + "identity": "tests/test_native_collection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_current_skill_lib_head_satisfies_collection_contract/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeCollectionTest.test_current_skill_lib_head_satisfies_collection_contract", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::method:NativeCollectionTest.test_current_skill_lib_head_satisfies_collection_contract", + "decorators": [], + "kind": "method", + "name": "test_current_skill_lib_head_satisfies_collection_contract", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::class:NativeCollectionTest", + "qualified_name": "NativeCollectionTest.test_current_skill_lib_head_satisfies_collection_contract", + "signature": "def test_current_skill_lib_head_satisfies_collection_contract(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 226, + "span": { + "end": { + "byte": 12609, + "column": 149, + "line": 226 + }, + "start": { + "byte": 11276, + "column": 4, + "line": 208 + } + }, + "start_line": 208 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_current_skill_lib_head_satisfies_collection_contract", + "identity": "NativeCollectionTest.test_current_skill_lib_head_satisfies_collection_contract", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_declared_revision_must_match_available_git_head/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeCollectionTest.test_declared_revision_must_match_available_git_head", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::method:NativeCollectionTest.test_declared_revision_must_match_available_git_head", + "decorators": [], + "kind": "method", + "name": "test_declared_revision_must_match_available_git_head", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::class:NativeCollectionTest", + "qualified_name": "NativeCollectionTest.test_declared_revision_must_match_available_git_head", + "signature": "def test_declared_revision_must_match_available_git_head(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 206, + "span": { + "end": { + "byte": 11270, + "column": 107, + "line": 206 + }, + "start": { + "byte": 10392, + "column": 4, + "line": 194 + } + }, + "start_line": 194 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_declared_revision_must_match_available_git_head", + "identity": "NativeCollectionTest.test_declared_revision_must_match_available_git_head", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_generated_collection_is_accounted_for_without_self_ingestion/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeCollectionTest.test_generated_collection_is_accounted_for_without_self_ingestion", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::method:NativeCollectionTest.test_generated_collection_is_accounted_for_without_self_ingestion", + "decorators": [], + "kind": "method", + "name": "test_generated_collection_is_accounted_for_without_self_ingestion", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::class:NativeCollectionTest", + "qualified_name": "NativeCollectionTest.test_generated_collection_is_accounted_for_without_self_ingestion", + "signature": "def test_generated_collection_is_accounted_for_without_self_ingestion(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 182, + "span": { + "end": { + "byte": 9839, + "column": 127, + "line": 182 + }, + "start": { + "byte": 9031, + "column": 4, + "line": 171 + } + }, + "start_line": 171 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_generated_collection_is_accounted_for_without_self_ingestion", + "identity": "NativeCollectionTest.test_generated_collection_is_accounted_for_without_self_ingestion", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_invalid_native_source_stays_visible/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeCollectionTest.test_invalid_native_source_stays_visible", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::method:NativeCollectionTest.test_invalid_native_source_stays_visible", + "decorators": [], + "kind": "method", + "name": "test_invalid_native_source_stays_visible", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::class:NativeCollectionTest", + "qualified_name": "NativeCollectionTest.test_invalid_native_source_stays_visible", + "signature": "def test_invalid_native_source_stays_visible(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 192, + "span": { + "end": { + "byte": 10386, + "column": 52, + "line": 192 + }, + "start": { + "byte": 9845, + "column": 4, + "line": 184 + } + }, + "start_line": 184 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_invalid_native_source_stays_visible", + "identity": "NativeCollectionTest.test_invalid_native_source_stays_visible", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_native_only_repository_needs_no_msdmd_redeclarations/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeCollectionTest.test_native_only_repository_needs_no_msdmd_redeclarations", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::method:NativeCollectionTest.test_native_only_repository_needs_no_msdmd_redeclarations", + "decorators": [], + "kind": "method", + "name": "test_native_only_repository_needs_no_msdmd_redeclarations", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::class:NativeCollectionTest", + "qualified_name": "NativeCollectionTest.test_native_only_repository_needs_no_msdmd_redeclarations", + "signature": "def test_native_only_repository_needs_no_msdmd_redeclarations(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 88, + "span": { + "end": { + "byte": 5008, + "column": 86, + "line": 88 + }, + "start": { + "byte": 504, + "column": 4, + "line": 20 + } + }, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_native_only_repository_needs_no_msdmd_redeclarations", + "identity": "NativeCollectionTest.test_native_only_repository_needs_no_msdmd_redeclarations", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_python_declared_encoding_and_source_lines_survive/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeCollectionTest.test_python_declared_encoding_and_source_lines_survive", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::method:NativeCollectionTest.test_python_declared_encoding_and_source_lines_survive", + "decorators": [], + "kind": "method", + "name": "test_python_declared_encoding_and_source_lines_survive", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::class:NativeCollectionTest", + "qualified_name": "NativeCollectionTest.test_python_declared_encoding_and_source_lines_survive", + "signature": "def test_python_declared_encoding_and_source_lines_survive(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 155, + "span": { + "end": { + "byte": 8280, + "column": 55, + "line": 155 + }, + "start": { + "byte": 7414, + "column": 4, + "line": 141 + } + }, + "start_line": 141 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_python_declared_encoding_and_source_lines_survive", + "identity": "NativeCollectionTest.test_python_declared_encoding_and_source_lines_survive", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_python_strings_do_not_create_block_declarations/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeCollectionTest.test_python_strings_do_not_create_block_declarations", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::method:NativeCollectionTest.test_python_strings_do_not_create_block_declarations", + "decorators": [], + "kind": "method", + "name": "test_python_strings_do_not_create_block_declarations", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::class:NativeCollectionTest", + "qualified_name": "NativeCollectionTest.test_python_strings_do_not_create_block_declarations", + "signature": "def test_python_strings_do_not_create_block_declarations(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 139, + "span": { + "end": { + "byte": 7408, + "column": 56, + "line": 139 + }, + "start": { + "byte": 6883, + "column": 4, + "line": 125 + } + }, + "start_line": 125 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_python_strings_do_not_create_block_declarations", + "identity": "NativeCollectionTest.test_python_strings_do_not_create_block_declarations", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_qualified_sources_and_duplicate_identity_diagnostics/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeCollectionTest.test_qualified_sources_and_duplicate_identity_diagnostics", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::method:NativeCollectionTest.test_qualified_sources_and_duplicate_identity_diagnostics", + "decorators": [], + "kind": "method", + "name": "test_qualified_sources_and_duplicate_identity_diagnostics", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::class:NativeCollectionTest", + "qualified_name": "NativeCollectionTest.test_qualified_sources_and_duplicate_identity_diagnostics", + "signature": "def test_qualified_sources_and_duplicate_identity_diagnostics(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 109, + "span": { + "end": { + "byte": 6127, + "column": 81, + "line": 109 + }, + "start": { + "byte": 5014, + "column": 4, + "line": 90 + } + }, + "start_line": 90 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_qualified_sources_and_duplicate_identity_diagnostics", + "identity": "NativeCollectionTest.test_qualified_sources_and_duplicate_identity_diagnostics", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_replay_is_byte_identical_for_same_snapshot/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeCollectionTest.test_replay_is_byte_identical_for_same_snapshot", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::method:NativeCollectionTest.test_replay_is_byte_identical_for_same_snapshot", + "decorators": [], + "kind": "method", + "name": "test_replay_is_byte_identical_for_same_snapshot", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::class:NativeCollectionTest", + "qualified_name": "NativeCollectionTest.test_replay_is_byte_identical_for_same_snapshot", + "signature": "def test_replay_is_byte_identical_for_same_snapshot(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 169, + "span": { + "end": { + "byte": 9025, + "column": 95, + "line": 169 + }, + "start": { + "byte": 8286, + "column": 4, + "line": 157 + } + }, + "start_line": 157 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_replay_is_byte_identical_for_same_snapshot", + "identity": "NativeCollectionTest.test_replay_is_byte_identical_for_same_snapshot", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_same_symbol_name_in_two_packages_stays_distinct/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeCollectionTest.test_same_symbol_name_in_two_packages_stays_distinct", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::method:NativeCollectionTest.test_same_symbol_name_in_two_packages_stays_distinct", + "decorators": [], + "kind": "method", + "name": "test_same_symbol_name_in_two_packages_stays_distinct", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::class:NativeCollectionTest", + "qualified_name": "NativeCollectionTest.test_same_symbol_name_in_two_packages_stays_distinct", + "signature": "def test_same_symbol_name_in_two_packages_stays_distinct(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 123, + "span": { + "end": { + "byte": 6877, + "column": 80, + "line": 123 + }, + "start": { + "byte": 6133, + "column": 4, + "line": 111 + } + }, + "start_line": 111 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest.test_same_symbol_name_in_two_packages_stays_distinct", + "identity": "NativeCollectionTest.test_same_symbol_name_in_two_packages_stays_distinct", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "NativeCollectionTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_collection.py::class:NativeCollectionTest", + "decorators": [], + "kind": "class", + "name": "NativeCollectionTest", + "parent_identity": null, + "qualified_name": "NativeCollectionTest", + "signature": "class NativeCollectionTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "06b69562dfebed7277ca091afaf547aecd9a1273a5db9df7bf0297c25c030c71", + "file": "tests/test_native_collection.py", + "location": { + "end_line": 226, + "span": { + "end": { + "byte": 12609, + "column": 149, + "line": 226 + }, + "start": { + "byte": 453, + "column": 0, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_collection.py#subject/symbol/NativeCollectionTest", + "identity": "NativeCollectionTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_encoding_boundary.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Malformed-source regression: python -m unittest tests.test_native_encoding_boundary.", + "text": "Malformed-source regression: python -m unittest tests.test_native_encoding_boundary." + } + }, + "origin": "native", + "source": { + "content_sha256": "fd47c93072fd0db383b17fc4492436a7031b5bb9984f2bf1903799c4919aac61", + "file": "tests/test_native_encoding_boundary.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 90, + "column": 90, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py", + "identity": "tests/test_native_encoding_boundary.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fd47c93072fd0db383b17fc4492436a7031b5bb9984f2bf1903799c4919aac61", + "file": "tests/test_native_encoding_boundary.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py", + "identity": "tests/test_native_encoding_boundary.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fd47c93072fd0db383b17fc4492436a7031b5bb9984f2bf1903799c4919aac61", + "file": "tests/test_native_encoding_boundary.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py", + "identity": "tests/test_native_encoding_boundary.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fd47c93072fd0db383b17fc4492436a7031b5bb9984f2bf1903799c4919aac61", + "file": "tests/test_native_encoding_boundary.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py", + "identity": "tests/test_native_encoding_boundary.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collect:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collect" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fd47c93072fd0db383b17fc4492436a7031b5bb9984f2bf1903799c4919aac61", + "file": "tests/test_native_encoding_boundary.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py", + "identity": "tests/test_native_encoding_boundary.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collection_errors:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collection_errors" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fd47c93072fd0db383b17fc4492436a7031b5bb9984f2bf1903799c4919aac61", + "file": "tests/test_native_encoding_boundary.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/module/tests%2Ftest_native_encoding_boundary.py", + "identity": "tests/test_native_encoding_boundary.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/symbol/NativeEncodingBoundaryTests.test_malformed_code_with_ratios_preserves_other_files_and_reports_error/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeEncodingBoundaryTests.test_malformed_code_with_ratios_preserves_other_files_and_reports_error", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_encoding_boundary.py::method:NativeEncodingBoundaryTests.test_malformed_code_with_ratios_preserves_other_files_and_reports_error", + "decorators": [], + "kind": "method", + "name": "test_malformed_code_with_ratios_preserves_other_files_and_reports_error", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_encoding_boundary.py::class:NativeEncodingBoundaryTests", + "qualified_name": "NativeEncodingBoundaryTests.test_malformed_code_with_ratios_preserves_other_files_and_reports_error", + "signature": "def test_malformed_code_with_ratios_preserves_other_files_and_reports_error(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fd47c93072fd0db383b17fc4492436a7031b5bb9984f2bf1903799c4919aac61", + "file": "tests/test_native_encoding_boundary.py", + "location": { + "end_line": 21, + "span": { + "end": { + "byte": 1297, + "column": 152, + "line": 21 + }, + "start": { + "byte": 262, + "column": 4, + "line": 10 + } + }, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/symbol/NativeEncodingBoundaryTests.test_malformed_code_with_ratios_preserves_other_files_and_reports_error", + "identity": "NativeEncodingBoundaryTests.test_malformed_code_with_ratios_preserves_other_files_and_reports_error", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/symbol/NativeEncodingBoundaryTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "NativeEncodingBoundaryTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_encoding_boundary.py::class:NativeEncodingBoundaryTests", + "decorators": [], + "kind": "class", + "name": "NativeEncodingBoundaryTests", + "parent_identity": null, + "qualified_name": "NativeEncodingBoundaryTests", + "signature": "class NativeEncodingBoundaryTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fd47c93072fd0db383b17fc4492436a7031b5bb9984f2bf1903799c4919aac61", + "file": "tests/test_native_encoding_boundary.py", + "location": { + "end_line": 21, + "span": { + "end": { + "byte": 1297, + "column": 152, + "line": 21 + }, + "start": { + "byte": 204, + "column": 0, + "line": 9 + } + }, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_encoding_boundary.py#subject/symbol/NativeEncodingBoundaryTests", + "identity": "NativeEncodingBoundaryTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "PR 111 closure regressions. Usage: python -m unittest tests.test_native_review_closure.", + "text": "PR 111 closure regressions. Usage: python -m unittest tests.test_native_review_closure." + } + }, + "origin": "native", + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 93, + "column": 93, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:msdmd.readers:10", + "value": { + "alias": "readers", + "kind": "import", + "level": 0, + "module": "msdmd.readers", + "name": "msdmd.readers" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest.mock:patch:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "unittest.mock", + "name": "patch" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collect:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collect" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collection_errors:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collection_errors" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:implementation_digest:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "implementation_digest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/module/tests%2Ftest_native_review_closure.py", + "identity": "tests/test_native_review_closure.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.collection/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.collection", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.collection", + "decorators": [], + "kind": "method", + "name": "collection", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.collection", + "signature": "def collection(self, files, **options)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 23, + "span": { + "end": { + "byte": 858, + "column": 78, + "line": 23 + }, + "start": { + "byte": 414, + "column": 4, + "line": 16 + } + }, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.collection", + "identity": "NativeReviewClosure.collection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.facts/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.facts", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.facts", + "decorators": [], + "kind": "method", + "name": "facts", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.facts", + "signature": "def facts(self, result, kind=None)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 26, + "span": { + "end": { + "byte": 989, + "column": 89, + "line": 26 + }, + "start": { + "byte": 864, + "column": 4, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.facts", + "identity": "NativeReviewClosure.facts", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_conditional_only_python_exports_are_unresolved/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_conditional_only_python_exports_are_unresolved", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_conditional_only_python_exports_are_unresolved", + "decorators": [], + "kind": "method", + "name": "test_conditional_only_python_exports_are_unresolved", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_conditional_only_python_exports_are_unresolved", + "signature": "def test_conditional_only_python_exports_are_unresolved(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 101, + "span": { + "end": { + "byte": 6205, + "column": 91, + "line": 101 + }, + "start": { + "byte": 5897, + "column": 4, + "line": 98 + } + }, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_conditional_only_python_exports_are_unresolved", + "identity": "NativeReviewClosure.test_conditional_only_python_exports_are_unresolved", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_default_export_assignment_links_the_named_symbol/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_default_export_assignment_links_the_named_symbol", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_default_export_assignment_links_the_named_symbol", + "decorators": [], + "kind": "method", + "name": "test_default_export_assignment_links_the_named_symbol", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_default_export_assignment_links_the_named_symbol", + "signature": "def test_default_export_assignment_links_the_named_symbol(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 57, + "span": { + "end": { + "byte": 3141, + "column": 109, + "line": 57 + }, + "start": { + "byte": 2418, + "column": 4, + "line": 49 + } + }, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_default_export_assignment_links_the_named_symbol", + "identity": "NativeReviewClosure.test_default_export_assignment_links_the_named_symbol", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_default_expression_and_export_equals_are_not_dropped/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_default_expression_and_export_equals_are_not_dropped", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_default_expression_and_export_equals_are_not_dropped", + "decorators": [], + "kind": "method", + "name": "test_default_expression_and_export_equals_are_not_dropped", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_default_expression_and_export_equals_are_not_dropped", + "signature": "def test_default_expression_and_export_equals_are_not_dropped(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 77, + "span": { + "end": { + "byte": 4562, + "column": 109, + "line": 77 + }, + "start": { + "byte": 4069, + "column": 4, + "line": 72 + } + }, + "start_line": 72 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_default_expression_and_export_equals_are_not_dropped", + "identity": "NativeReviewClosure.test_default_expression_and_export_equals_are_not_dropped", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_gitignore_trailing_spaces_follow_git_escaping/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_gitignore_trailing_spaces_follow_git_escaping", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_gitignore_trailing_spaces_follow_git_escaping", + "decorators": [], + "kind": "method", + "name": "test_gitignore_trailing_spaces_follow_git_escaping", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_gitignore_trailing_spaces_follow_git_escaping", + "signature": "def test_gitignore_trailing_spaces_follow_git_escaping(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 175, + "span": { + "end": { + "byte": 9941, + "column": 45, + "line": 175 + }, + "start": { + "byte": 9143, + "column": 4, + "line": 164 + } + }, + "start_line": 164 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_gitignore_trailing_spaces_follow_git_escaping", + "identity": "NativeReviewClosure.test_gitignore_trailing_spaces_follow_git_escaping", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_literal_python_exports_remain_static/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_literal_python_exports_remain_static", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_literal_python_exports_remain_static", + "decorators": [], + "kind": "method", + "name": "test_literal_python_exports_remain_static", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_literal_python_exports_remain_static", + "signature": "def test_literal_python_exports_remain_static(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 84, + "span": { + "end": { + "byte": 4973, + "column": 47, + "line": 84 + }, + "start": { + "byte": 4568, + "column": 4, + "line": 79 + } + }, + "start_line": 79 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_literal_python_exports_remain_static", + "identity": "NativeReviewClosure.test_literal_python_exports_remain_static", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_mutated_or_escaped_python_exports_are_partial/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_mutated_or_escaped_python_exports_are_partial", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_mutated_or_escaped_python_exports_are_partial", + "decorators": [], + "kind": "method", + "name": "test_mutated_or_escaped_python_exports_are_partial", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_mutated_or_escaped_python_exports_are_partial", + "signature": "def test_mutated_or_escaped_python_exports_are_partial(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 96, + "span": { + "end": { + "byte": 5891, + "column": 114, + "line": 96 + }, + "start": { + "byte": 4979, + "column": 4, + "line": 86 + } + }, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_mutated_or_escaped_python_exports_are_partial", + "identity": "NativeReviewClosure.test_mutated_or_escaped_python_exports_are_partial", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_named_and_anonymous_default_declarations_are_explicit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_named_and_anonymous_default_declarations_are_explicit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_named_and_anonymous_default_declarations_are_explicit", + "decorators": [], + "kind": "method", + "name": "test_named_and_anonymous_default_declarations_are_explicit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_named_and_anonymous_default_declarations_are_explicit", + "signature": "def test_named_and_anonymous_default_declarations_are_explicit(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 70, + "span": { + "end": { + "byte": 4063, + "column": 118, + "line": 70 + }, + "start": { + "byte": 3147, + "column": 4, + "line": 59 + } + }, + "start_line": 59 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_named_and_anonymous_default_declarations_are_explicit", + "identity": "NativeReviewClosure.test_named_and_anonymous_default_declarations_are_explicit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes.changed/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes.changed", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::function:NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes.changed", + "decorators": [], + "kind": "function", + "name": "changed", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes", + "qualified_name": "NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes.changed", + "signature": "def changed(source)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 156, + "span": { + "end": { + "byte": 8880, + "column": 99, + "line": 156 + }, + "start": { + "byte": 8722, + "column": 8, + "line": 154 + } + }, + "start_line": 154 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes.changed", + "identity": "NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes.changed", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes", + "decorators": [], + "kind": "method", + "name": "test_reader_identity_changes_when_universal_parser_changes", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes", + "signature": "def test_reader_identity_changes_when_universal_parser_changes(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 162, + "span": { + "end": { + "byte": 9137, + "column": 47, + "line": 162 + }, + "start": { + "byte": 8446, + "column": 4, + "line": 149 + } + }, + "start_line": 149 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes", + "identity": "NativeReviewClosure.test_reader_identity_changes_when_universal_parser_changes", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_repeated_spdx_headers_have_distinct_addresses/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_repeated_spdx_headers_have_distinct_addresses", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_repeated_spdx_headers_have_distinct_addresses", + "decorators": [], + "kind": "method", + "name": "test_repeated_spdx_headers_have_distinct_addresses", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_repeated_spdx_headers_have_distinct_addresses", + "signature": "def test_repeated_spdx_headers_have_distinct_addresses(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 115, + "span": { + "end": { + "byte": 7059, + "column": 105, + "line": 115 + }, + "start": { + "byte": 6211, + "column": 4, + "line": 103 + } + }, + "start_line": 103 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_repeated_spdx_headers_have_distinct_addresses", + "identity": "NativeReviewClosure.test_repeated_spdx_headers_have_distinct_addresses", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_typescript_comments_use_innermost_symbol_even_in_empty_bodies/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_typescript_comments_use_innermost_symbol_even_in_empty_bodies", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_typescript_comments_use_innermost_symbol_even_in_empty_bodies", + "decorators": [], + "kind": "method", + "name": "test_typescript_comments_use_innermost_symbol_even_in_empty_bodies", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_typescript_comments_use_innermost_symbol_even_in_empty_bodies", + "signature": "def test_typescript_comments_use_innermost_symbol_even_in_empty_bodies(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 141, + "span": { + "end": { + "byte": 8068, + "column": 77, + "line": 141 + }, + "start": { + "byte": 7065, + "column": 4, + "line": 117 + } + }, + "start_line": 117 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_typescript_comments_use_innermost_symbol_even_in_empty_bodies", + "identity": "NativeReviewClosure.test_typescript_comments_use_innermost_symbol_even_in_empty_bodies", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_typescript_literal_comment_lookalikes_are_not_comments/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_typescript_literal_comment_lookalikes_are_not_comments", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_typescript_literal_comment_lookalikes_are_not_comments", + "decorators": [], + "kind": "method", + "name": "test_typescript_literal_comment_lookalikes_are_not_comments", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_typescript_literal_comment_lookalikes_are_not_comments", + "signature": "def test_typescript_literal_comment_lookalikes_are_not_comments(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 147, + "span": { + "end": { + "byte": 8440, + "column": 55, + "line": 147 + }, + "start": { + "byte": 8074, + "column": 4, + "line": 143 + } + }, + "start_line": 143 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_typescript_literal_comment_lookalikes_are_not_comments", + "identity": "NativeReviewClosure.test_typescript_literal_comment_lookalikes_are_not_comments", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_xml_sensitive_tags_and_namespaced_attributes_are_redacted/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_xml_sensitive_tags_and_namespaced_attributes_are_redacted", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_xml_sensitive_tags_and_namespaced_attributes_are_redacted", + "decorators": [], + "kind": "method", + "name": "test_xml_sensitive_tags_and_namespaced_attributes_are_redacted", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_xml_sensitive_tags_and_namespaced_attributes_are_redacted", + "signature": "def test_xml_sensitive_tags_and_namespaced_attributes_are_redacted(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 41, + "span": { + "end": { + "byte": 2046, + "column": 128, + "line": 41 + }, + "start": { + "byte": 995, + "column": 4, + "line": 28 + } + }, + "start_line": 28 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_xml_sensitive_tags_and_namespaced_attributes_are_redacted", + "identity": "NativeReviewClosure.test_xml_sensitive_tags_and_namespaced_attributes_are_redacted", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_xml_unrelated_content_is_preserved/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewClosure.test_xml_unrelated_content_is_preserved", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::method:NativeReviewClosure.test_xml_unrelated_content_is_preserved", + "decorators": [], + "kind": "method", + "name": "test_xml_unrelated_content_is_preserved", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "qualified_name": "NativeReviewClosure.test_xml_unrelated_content_is_preserved", + "signature": "def test_xml_unrelated_content_is_preserved(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 47, + "span": { + "end": { + "byte": 2412, + "column": 97, + "line": 47 + }, + "start": { + "byte": 2052, + "column": 4, + "line": 43 + } + }, + "start_line": 43 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure.test_xml_unrelated_content_is_preserved", + "identity": "NativeReviewClosure.test_xml_unrelated_content_is_preserved", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "NativeReviewClosure", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_closure.py::class:NativeReviewClosure", + "decorators": [], + "kind": "class", + "name": "NativeReviewClosure", + "parent_identity": null, + "qualified_name": "NativeReviewClosure", + "signature": "class NativeReviewClosure(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1dc9bf55660fe56db0baffa2a0eb4a395e69487b638c60e3ab038468648d1c24", + "file": "tests/test_native_review_closure.py", + "location": { + "end_line": 175, + "span": { + "end": { + "byte": 9941, + "column": 45, + "line": 175 + }, + "start": { + "byte": 364, + "column": 0, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_closure.py#subject/symbol/NativeReviewClosure", + "identity": "NativeReviewClosure", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Reviewed regressions: python -m unittest tests.test_native_review_regressions.", + "text": "Reviewed regressions: python -m unittest tests.test_native_review_regressions." + } + }, + "origin": "native", + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 84, + "column": 84, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "identity": "tests/test_native_review_regressions.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "identity": "tests/test_native_review_regressions.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "identity": "tests/test_native_review_regressions.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "identity": "tests/test_native_review_regressions.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "identity": "tests/test_native_review_regressions.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "identity": "tests/test_native_review_regressions.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest.mock:patch:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "unittest.mock", + "name": "patch" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "identity": "tests/test_native_review_regressions.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collect:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collect" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "identity": "tests/test_native_review_regressions.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collection_errors:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collection_errors" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "identity": "tests/test_native_review_regressions.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:parse_json:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "parse_json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "identity": "tests/test_native_review_regressions.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:parse_yaml:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "parse_yaml" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/module/tests%2Ftest_native_review_regressions.py", + "identity": "tests/test_native_review_regressions.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.collection/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.collection", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.collection", + "decorators": [], + "kind": "method", + "name": "collection", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.collection", + "signature": "def collection(self, files, **options)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 21, + "span": { + "end": { + "byte": 809, + "column": 78, + "line": 21 + }, + "start": { + "byte": 363, + "column": 4, + "line": 14 + } + }, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.collection", + "identity": "NativeReviewRegressions.collection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.facts/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.facts", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.facts", + "decorators": [], + "kind": "method", + "name": "facts", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.facts", + "signature": "def facts(self, result, namespace=None, kind=None)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 25, + "span": { + "end": { + "byte": 1034, + "column": 56, + "line": 25 + }, + "start": { + "byte": 815, + "column": 4, + "line": 23 + } + }, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.facts", + "identity": "NativeReviewRegressions.facts", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_ambiguous_header_block_candidates_are_not_silent_success/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_ambiguous_header_block_candidates_are_not_silent_success", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_ambiguous_header_block_candidates_are_not_silent_success", + "decorators": [], + "kind": "method", + "name": "test_ambiguous_header_block_candidates_are_not_silent_success", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_ambiguous_header_block_candidates_are_not_silent_success", + "signature": "def test_ambiguous_header_block_candidates_are_not_silent_success(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 42, + "span": { + "end": { + "byte": 2090, + "column": 48, + "line": 42 + }, + "start": { + "byte": 1700, + "column": 4, + "line": 37 + } + }, + "start_line": 37 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_ambiguous_header_block_candidates_are_not_silent_success", + "identity": "NativeReviewRegressions.test_ambiguous_header_block_candidates_are_not_silent_success", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_ant_project_xml_is_not_maven/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_ant_project_xml_is_not_maven", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_ant_project_xml_is_not_maven", + "decorators": [], + "kind": "method", + "name": "test_ant_project_xml_is_not_maven", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_ant_project_xml_is_not_maven", + "signature": "def test_ant_project_xml_is_not_maven(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 117, + "span": { + "end": { + "byte": 7258, + "column": 82, + "line": 117 + }, + "start": { + "byte": 6830, + "column": 4, + "line": 112 + } + }, + "start_line": 112 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_ant_project_xml_is_not_maven", + "identity": "NativeReviewRegressions.test_ant_project_xml_is_not_maven", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_every_systemd_environment_assignment_is_redacted/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_every_systemd_environment_assignment_is_redacted", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_every_systemd_environment_assignment_is_redacted", + "decorators": [], + "kind": "method", + "name": "test_every_systemd_environment_assignment_is_redacted", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_every_systemd_environment_assignment_is_redacted", + "signature": "def test_every_systemd_environment_assignment_is_redacted(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 62, + "span": { + "end": { + "byte": 3370, + "column": 69, + "line": 62 + }, + "start": { + "byte": 2698, + "column": 4, + "line": 53 + } + }, + "start_line": 53 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_every_systemd_environment_assignment_is_redacted", + "identity": "NativeReviewRegressions.test_every_systemd_environment_assignment_is_redacted", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_explicit_integral_yaml_float_is_already_supported/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_explicit_integral_yaml_float_is_already_supported", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_explicit_integral_yaml_float_is_already_supported", + "decorators": [], + "kind": "method", + "name": "test_explicit_integral_yaml_float_is_already_supported", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_explicit_integral_yaml_float_is_already_supported", + "signature": "def test_explicit_integral_yaml_float_is_already_supported(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 97, + "span": { + "end": { + "byte": 5908, + "column": 43, + "line": 97 + }, + "start": { + "byte": 5700, + "column": 4, + "line": 94 + } + }, + "start_line": 94 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_explicit_integral_yaml_float_is_already_supported", + "identity": "NativeReviewRegressions.test_explicit_integral_yaml_float_is_already_supported", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_json_numeric_lexemes_survive_javascript_projection/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_json_numeric_lexemes_survive_javascript_projection", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_json_numeric_lexemes_survive_javascript_projection", + "decorators": [], + "kind": "method", + "name": "test_json_numeric_lexemes_survive_javascript_projection", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_json_numeric_lexemes_survive_javascript_projection", + "signature": "def test_json_numeric_lexemes_survive_javascript_projection(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 92, + "span": { + "end": { + "byte": 5694, + "column": 133, + "line": 92 + }, + "start": { + "byte": 4622, + "column": 4, + "line": 80 + } + }, + "start_line": 80 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_json_numeric_lexemes_survive_javascript_projection", + "identity": "NativeReviewRegressions.test_json_numeric_lexemes_survive_javascript_projection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_local_typescript_exports_keep_aliases_and_type_only_standing/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_local_typescript_exports_keep_aliases_and_type_only_standing", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_local_typescript_exports_keep_aliases_and_type_only_standing", + "decorators": [], + "kind": "method", + "name": "test_local_typescript_exports_keep_aliases_and_type_only_standing", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_local_typescript_exports_keep_aliases_and_type_only_standing", + "signature": "def test_local_typescript_exports_keep_aliases_and_type_only_standing(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 110, + "span": { + "end": { + "byte": 6824, + "column": 46, + "line": 110 + }, + "start": { + "byte": 5914, + "column": 4, + "line": 99 + } + }, + "start_line": 99 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_local_typescript_exports_keep_aliases_and_type_only_standing", + "identity": "NativeReviewRegressions.test_local_typescript_exports_keep_aliases_and_type_only_standing", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_missing_comment_parser_retains_uncertified_candidates_and_fails_closed/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_missing_comment_parser_retains_uncertified_candidates_and_fails_closed", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_missing_comment_parser_retains_uncertified_candidates_and_fails_closed", + "decorators": [], + "kind": "method", + "name": "test_missing_comment_parser_retains_uncertified_candidates_and_fails_closed", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_missing_comment_parser_retains_uncertified_candidates_and_fails_closed", + "signature": "def test_missing_comment_parser_retains_uncertified_candidates_and_fails_closed(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 35, + "span": { + "end": { + "byte": 1694, + "column": 48, + "line": 35 + }, + "start": { + "byte": 1040, + "column": 4, + "line": 27 + } + }, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_missing_comment_parser_retains_uncertified_candidates_and_fails_closed", + "identity": "NativeReviewRegressions.test_missing_comment_parser_retains_uncertified_candidates_and_fails_closed", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_requirement_includes_do_not_satisfy_required_source_policy/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_requirement_includes_do_not_satisfy_required_source_policy", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_requirement_includes_do_not_satisfy_required_source_policy", + "decorators": [], + "kind": "method", + "name": "test_requirement_includes_do_not_satisfy_required_source_policy", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_requirement_includes_do_not_satisfy_required_source_policy", + "signature": "def test_requirement_includes_do_not_satisfy_required_source_policy(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 78, + "span": { + "end": { + "byte": 4616, + "column": 79, + "line": 78 + }, + "start": { + "byte": 3860, + "column": 4, + "line": 71 + } + }, + "start_line": 71 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_requirement_includes_do_not_satisfy_required_source_policy", + "identity": "NativeReviewRegressions.test_requirement_includes_do_not_satisfy_required_source_policy", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_svg_uses_same_no_dtd_utf8_boundary_as_other_xml/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_svg_uses_same_no_dtd_utf8_boundary_as_other_xml", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_svg_uses_same_no_dtd_utf8_boundary_as_other_xml", + "decorators": [], + "kind": "method", + "name": "test_svg_uses_same_no_dtd_utf8_boundary_as_other_xml", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_svg_uses_same_no_dtd_utf8_boundary_as_other_xml", + "signature": "def test_svg_uses_same_no_dtd_utf8_boundary_as_other_xml(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 132, + "span": { + "end": { + "byte": 8326, + "column": 106, + "line": 132 + }, + "start": { + "byte": 7672, + "column": 4, + "line": 125 + } + }, + "start_line": 125 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_svg_uses_same_no_dtd_utf8_boundary_as_other_xml", + "identity": "NativeReviewRegressions.test_svg_uses_same_no_dtd_utf8_boundary_as_other_xml", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_systemd_continuations_preserve_separators_and_skip_comments/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_systemd_continuations_preserve_separators_and_skip_comments", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_systemd_continuations_preserve_separators_and_skip_comments", + "decorators": [], + "kind": "method", + "name": "test_systemd_continuations_preserve_separators_and_skip_comments", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_systemd_continuations_preserve_separators_and_skip_comments", + "signature": "def test_systemd_continuations_preserve_separators_and_skip_comments(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 51, + "span": { + "end": { + "byte": 2692, + "column": 72, + "line": 51 + }, + "start": { + "byte": 2096, + "column": 4, + "line": 44 + } + }, + "start_line": 44 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_systemd_continuations_preserve_separators_and_skip_comments", + "identity": "NativeReviewRegressions.test_systemd_continuations_preserve_separators_and_skip_comments", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_unimplemented_environment_escaping_is_withheld_and_partial/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_unimplemented_environment_escaping_is_withheld_and_partial", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_unimplemented_environment_escaping_is_withheld_and_partial", + "decorators": [], + "kind": "method", + "name": "test_unimplemented_environment_escaping_is_withheld_and_partial", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_unimplemented_environment_escaping_is_withheld_and_partial", + "signature": "def test_unimplemented_environment_escaping_is_withheld_and_partial(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 69, + "span": { + "end": { + "byte": 3854, + "column": 107, + "line": 69 + }, + "start": { + "byte": 3376, + "column": 4, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_unimplemented_environment_escaping_is_withheld_and_partial", + "identity": "NativeReviewRegressions.test_unimplemented_environment_escaping_is_withheld_and_partial", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_unnamespaced_pom_requires_model_version_discriminator/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeReviewRegressions.test_unnamespaced_pom_requires_model_version_discriminator", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::method:NativeReviewRegressions.test_unnamespaced_pom_requires_model_version_discriminator", + "decorators": [], + "kind": "method", + "name": "test_unnamespaced_pom_requires_model_version_discriminator", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "qualified_name": "NativeReviewRegressions.test_unnamespaced_pom_requires_model_version_discriminator", + "signature": "def test_unnamespaced_pom_requires_model_version_discriminator(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 123, + "span": { + "end": { + "byte": 7666, + "column": 70, + "line": 123 + }, + "start": { + "byte": 7264, + "column": 4, + "line": 119 + } + }, + "start_line": 119 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions.test_unnamespaced_pom_requires_model_version_discriminator", + "identity": "NativeReviewRegressions.test_unnamespaced_pom_requires_model_version_discriminator", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "NativeReviewRegressions", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_review_regressions.py::class:NativeReviewRegressions", + "decorators": [], + "kind": "class", + "name": "NativeReviewRegressions", + "parent_identity": null, + "qualified_name": "NativeReviewRegressions", + "signature": "class NativeReviewRegressions(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "63439e7f5096b6c95a0cd496bd3e9faabe1c23826b1bdd437e60e66f65032f8c", + "file": "tests/test_native_review_regressions.py", + "location": { + "end_line": 132, + "span": { + "end": { + "byte": 8326, + "column": 106, + "line": 132 + }, + "start": { + "byte": 309, + "column": 0, + "line": 13 + } + }, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_review_regressions.py#subject/symbol/NativeReviewRegressions", + "identity": "NativeReviewRegressions", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::<module>", + "description": "All source metadata is supplied as inert fixture bytes. Tests distinguish syntax\nextraction, required information, source identity and claimed runtime evidence.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "End-to-end native reader fixtures: run python -m unittest tests.test_native_standards.", + "text": "End-to-end native reader fixtures: run python -m unittest tests.test_native_standards.\n\nAll source metadata is supplied as inert fixture bytes. Tests distinguish syntax\nextraction, required information, source identity and claimed runtime evidence.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 5, + "span": { + "end": { + "byte": 255, + "column": 3, + "line": 5 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "base64:base64:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "base64", + "name": "base64" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collect:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collect" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collection_errors:11", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collection_errors" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/12", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:parse_json:12", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "parse_json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/13", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:parse_yaml:13", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "parse_yaml" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/14", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:parse_xml:14", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "parse_xml" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/15", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.module_projection:project_python_bytes:15", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.module_projection", + "name": "project_python_bytes" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/16", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.readers:read_native:16", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.readers", + "name": "read_native" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:6", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:7", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:8", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest.mock:patch:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "unittest.mock", + "name": "patch" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/module/tests%2Ftest_native_standards.py", + "identity": "tests/test_native_standards.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.collection/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.collection", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.collection", + "decorators": [], + "kind": "method", + "name": "collection", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.collection", + "signature": "def collection(self, files: dict[str, str | bytes], **options)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 34, + "span": { + "end": { + "byte": 1214, + "column": 78, + "line": 34 + }, + "start": { + "byte": 752, + "column": 4, + "line": 27 + } + }, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.collection", + "identity": "NativeStandardsTests.collection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.facts/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.facts", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.facts", + "decorators": [], + "kind": "method", + "name": "facts", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.facts", + "signature": "def facts(self, result, namespace=None, kind=None)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 38, + "span": { + "end": { + "byte": 1439, + "column": 56, + "line": 38 + }, + "start": { + "byte": 1220, + "column": 4, + "line": 36 + } + }, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.facts", + "identity": "NativeStandardsTests.facts", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_ambiguous_headers_and_macro_context_remain_visible/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_ambiguous_headers_and_macro_context_remain_visible", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_ambiguous_headers_and_macro_context_remain_visible", + "decorators": [], + "kind": "method", + "name": "test_ambiguous_headers_and_macro_context_remain_visible", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_ambiguous_headers_and_macro_context_remain_visible", + "signature": "def test_ambiguous_headers_and_macro_context_remain_visible(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 142, + "span": { + "end": { + "byte": 8138, + "column": 137, + "line": 142 + }, + "start": { + "byte": 7786, + "column": 4, + "line": 139 + } + }, + "start_line": 139 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_ambiguous_headers_and_macro_context_remain_visible", + "identity": "NativeStandardsTests.test_ambiguous_headers_and_macro_context_remain_visible", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_codeowners_precedence_and_ownerless_exemption/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_codeowners_precedence_and_ownerless_exemption", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_codeowners_precedence_and_ownerless_exemption", + "decorators": [], + "kind": "method", + "name": "test_codeowners_precedence_and_ownerless_exemption", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_codeowners_precedence_and_ownerless_exemption", + "signature": "def test_codeowners_precedence_and_ownerless_exemption(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 214, + "span": { + "end": { + "byte": 14268, + "column": 52, + "line": 214 + }, + "start": { + "byte": 13796, + "column": 4, + "line": 208 + } + }, + "start_line": 208 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_codeowners_precedence_and_ownerless_exemption", + "identity": "NativeStandardsTests.test_codeowners_precedence_and_ownerless_exemption", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_doxygen_dotnet_and_maven_xml/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_doxygen_dotnet_and_maven_xml", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_doxygen_dotnet_and_maven_xml", + "decorators": [], + "kind": "method", + "name": "test_doxygen_dotnet_and_maven_xml", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_doxygen_dotnet_and_maven_xml", + "signature": "def test_doxygen_dotnet_and_maven_xml(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 223, + "span": { + "end": { + "byte": 15077, + "column": 64, + "line": 223 + }, + "start": { + "byte": 14274, + "column": 4, + "line": 216 + } + }, + "start_line": 216 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_doxygen_dotnet_and_maven_xml", + "identity": "NativeStandardsTests.test_doxygen_dotnet_and_maven_xml", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_dsse_statement_is_decoded_without_signature_claim/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_dsse_statement_is_decoded_without_signature_claim", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_dsse_statement_is_decoded_without_signature_claim", + "decorators": [], + "kind": "method", + "name": "test_dsse_statement_is_decoded_without_signature_claim", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_dsse_statement_is_decoded_without_signature_claim", + "signature": "def test_dsse_statement_is_decoded_without_signature_claim(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 195, + "span": { + "end": { + "byte": 12883, + "column": 89, + "line": 195 + }, + "start": { + "byte": 12198, + "column": 4, + "line": 190 + } + }, + "start_line": 190 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_dsse_statement_is_decoded_without_signature_claim", + "identity": "NativeStandardsTests.test_dsse_statement_is_decoded_without_signature_claim", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_duplicate_native_ids_are_reported_without_dropping_witnesses/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_duplicate_native_ids_are_reported_without_dropping_witnesses", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_duplicate_native_ids_are_reported_without_dropping_witnesses", + "decorators": [], + "kind": "method", + "name": "test_duplicate_native_ids_are_reported_without_dropping_witnesses", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_duplicate_native_ids_are_reported_without_dropping_witnesses", + "signature": "def test_duplicate_native_ids_are_reported_without_dropping_witnesses(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 188, + "span": { + "end": { + "byte": 12192, + "column": 100, + "line": 188 + }, + "start": { + "byte": 11753, + "column": 4, + "line": 185 + } + }, + "start_line": 185 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_duplicate_native_ids_are_reported_without_dropping_witnesses", + "identity": "NativeStandardsTests.test_duplicate_native_ids_are_reported_without_dropping_witnesses", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_frontmatter_full_structure_is_available_without_redeclaration/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_frontmatter_full_structure_is_available_without_redeclaration", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_frontmatter_full_structure_is_available_without_redeclaration", + "decorators": [], + "kind": "method", + "name": "test_frontmatter_full_structure_is_available_without_redeclaration", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_frontmatter_full_structure_is_available_without_redeclaration", + "signature": "def test_frontmatter_full_structure_is_available_without_redeclaration(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 64, + "span": { + "end": { + "byte": 3160, + "column": 112, + "line": 64 + }, + "start": { + "byte": 2734, + "column": 4, + "line": 60 + } + }, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_frontmatter_full_structure_is_available_without_redeclaration", + "identity": "NativeStandardsTests.test_frontmatter_full_structure_is_available_without_redeclaration", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_json_schema_unknown_fields_and_citation/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_json_schema_unknown_fields_and_citation", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_json_schema_unknown_fields_and_citation", + "decorators": [], + "kind": "method", + "name": "test_json_schema_unknown_fields_and_citation", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_json_schema_unknown_fields_and_citation", + "signature": "def test_json_schema_unknown_fields_and_citation(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 161, + "span": { + "end": { + "byte": 9714, + "column": 97, + "line": 161 + }, + "start": { + "byte": 9097, + "column": 4, + "line": 156 + } + }, + "start_line": 156 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_json_schema_unknown_fields_and_citation", + "identity": "NativeStandardsTests.test_json_schema_unknown_fields_and_citation", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution", + "decorators": [], + "kind": "method", + "name": "test_large_collection_chunks_roundtrip_without_code_execution", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution", + "signature": "def test_large_collection_chunks_roundtrip_without_code_execution(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 262, + "span": { + "end": { + "byte": 17432, + "column": 37, + "line": 262 + }, + "start": { + "byte": 16621, + "column": 4, + "line": 250 + } + }, + "start_line": 250 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution", + "identity": "NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:render_typescript:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "render_typescript" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 251, + "start_line": 251 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution", + "identity": "NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.visualize:load_collection:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.visualize", + "name": "load_collection" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 252, + "start_line": 252 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution", + "identity": "NativeStandardsTests.test_large_collection_chunks_roundtrip_without_code_execution", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_missing_typescript_runtime_is_unsupported_not_empty_success/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_missing_typescript_runtime_is_unsupported_not_empty_success", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_missing_typescript_runtime_is_unsupported_not_empty_success", + "decorators": [], + "kind": "method", + "name": "test_missing_typescript_runtime_is_unsupported_not_empty_success", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_missing_typescript_runtime_is_unsupported_not_empty_success", + "signature": "def test_missing_typescript_runtime_is_unsupported_not_empty_success(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 125, + "span": { + "end": { + "byte": 6812, + "column": 132, + "line": 125 + }, + "start": { + "byte": 6268, + "column": 4, + "line": 120 + } + }, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_missing_typescript_runtime_is_unsupported_not_empty_success", + "identity": "NativeStandardsTests.test_missing_typescript_runtime_is_unsupported_not_empty_success", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_native_source_language_documentation_and_symbol_attachment/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_native_source_language_documentation_and_symbol_attachment", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_native_source_language_documentation_and_symbol_attachment", + "decorators": [], + "kind": "method", + "name": "test_native_source_language_documentation_and_symbol_attachment", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_native_source_language_documentation_and_symbol_attachment", + "signature": "def test_native_source_language_documentation_and_symbol_attachment(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 137, + "span": { + "end": { + "byte": 7780, + "column": 74, + "line": 137 + }, + "start": { + "byte": 6818, + "column": 4, + "line": 127 + } + }, + "start_line": 127 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_native_source_language_documentation_and_symbol_attachment", + "identity": "NativeStandardsTests.test_native_source_language_documentation_and_symbol_attachment", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_openapi_yaml_operations_and_local_or_external_refs/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_openapi_yaml_operations_and_local_or_external_refs", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_openapi_yaml_operations_and_local_or_external_refs", + "decorators": [], + "kind": "method", + "name": "test_openapi_yaml_operations_and_local_or_external_refs", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_openapi_yaml_operations_and_local_or_external_refs", + "signature": "def test_openapi_yaml_operations_and_local_or_external_refs(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 154, + "span": { + "end": { + "byte": 9091, + "column": 113, + "line": 154 + }, + "start": { + "byte": 8403, + "column": 4, + "line": 148 + } + }, + "start_line": 148 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_openapi_yaml_operations_and_local_or_external_refs", + "identity": "NativeStandardsTests.test_openapi_yaml_operations_and_local_or_external_refs", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_package_manifests_lockfiles_and_reuse_are_integrated/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_package_manifests_lockfiles_and_reuse_are_integrated", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_package_manifests_lockfiles_and_reuse_are_integrated", + "decorators": [], + "kind": "method", + "name": "test_package_manifests_lockfiles_and_reuse_are_integrated", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_package_manifests_lockfiles_and_reuse_are_integrated", + "signature": "def test_package_manifests_lockfiles_and_reuse_are_integrated(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 206, + "span": { + "end": { + "byte": 13790, + "column": 82, + "line": 206 + }, + "start": { + "byte": 12889, + "column": 4, + "line": 197 + } + }, + "start_line": 197 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_package_manifests_lockfiles_and_reuse_are_integrated", + "identity": "NativeStandardsTests.test_package_manifests_lockfiles_and_reuse_are_integrated", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_python_docstring_dialects_emit_structured_parameters/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_python_docstring_dialects_emit_structured_parameters", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_python_docstring_dialects_emit_structured_parameters", + "decorators": [], + "kind": "method", + "name": "test_python_docstring_dialects_emit_structured_parameters", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_python_docstring_dialects_emit_structured_parameters", + "signature": "def test_python_docstring_dialects_emit_structured_parameters(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 78, + "span": { + "end": { + "byte": 4183, + "column": 59, + "line": 78 + }, + "start": { + "byte": 3166, + "column": 4, + "line": 66 + } + }, + "start_line": 66 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_python_docstring_dialects_emit_structured_parameters", + "identity": "NativeStandardsTests.test_python_docstring_dialects_emit_structured_parameters", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_python_never_executes_fixture_or_dynamic_exports/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_python_never_executes_fixture_or_dynamic_exports", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_python_never_executes_fixture_or_dynamic_exports", + "decorators": [], + "kind": "method", + "name": "test_python_never_executes_fixture_or_dynamic_exports", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_python_never_executes_fixture_or_dynamic_exports", + "signature": "def test_python_never_executes_fixture_or_dynamic_exports(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 96, + "span": { + "end": { + "byte": 5536, + "column": 128, + "line": 96 + }, + "start": { + "byte": 5093, + "column": 4, + "line": 92 + } + }, + "start_line": 92 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_python_never_executes_fixture_or_dynamic_exports", + "identity": "NativeStandardsTests.test_python_never_executes_fixture_or_dynamic_exports", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_python_shared_attachment_and_blank_line_identity/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_python_shared_attachment_and_blank_line_identity", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_python_shared_attachment_and_blank_line_identity", + "decorators": [], + "kind": "method", + "name": "test_python_shared_attachment_and_blank_line_identity", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_python_shared_attachment_and_blank_line_identity", + "signature": "def test_python_shared_attachment_and_blank_line_identity(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 90, + "span": { + "end": { + "byte": 5087, + "column": 64, + "line": 90 + }, + "start": { + "byte": 4189, + "column": 4, + "line": 80 + } + }, + "start_line": 80 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_python_shared_attachment_and_blank_line_identity", + "identity": "NativeStandardsTests.test_python_shared_attachment_and_blank_line_identity", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_required_facts_are_witnessed_and_missing_information_fails/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_required_facts_are_witnessed_and_missing_information_fails", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_required_facts_are_witnessed_and_missing_information_fails", + "decorators": [], + "kind": "method", + "name": "test_required_facts_are_witnessed_and_missing_information_fails", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_required_facts_are_witnessed_and_missing_information_fails", + "signature": "def test_required_facts_are_witnessed_and_missing_information_fails(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 232, + "span": { + "end": { + "byte": 15705, + "column": 69, + "line": 232 + }, + "start": { + "byte": 15083, + "column": 4, + "line": 225 + } + }, + "start_line": 225 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_required_facts_are_witnessed_and_missing_information_fails", + "identity": "NativeStandardsTests.test_required_facts_are_witnessed_and_missing_information_fails", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_sarif_and_junit_are_reported_evidence_not_verified_behavior/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_sarif_and_junit_are_reported_evidence_not_verified_behavior", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_sarif_and_junit_are_reported_evidence_not_verified_behavior", + "decorators": [], + "kind": "method", + "name": "test_sarif_and_junit_are_reported_evidence_not_verified_behavior", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_sarif_and_junit_are_reported_evidence_not_verified_behavior", + "signature": "def test_sarif_and_junit_are_reported_evidence_not_verified_behavior(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 176, + "span": { + "end": { + "byte": 11050, + "column": 82, + "line": 176 + }, + "start": { + "byte": 10256, + "column": 4, + "line": 170 + } + }, + "start_line": 170 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_sarif_and_junit_are_reported_evidence_not_verified_behavior", + "identity": "NativeStandardsTests.test_sarif_and_junit_are_reported_evidence_not_verified_behavior", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_snapshot_replay_and_cli_drift_do_not_depend_on_git_head/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_snapshot_replay_and_cli_drift_do_not_depend_on_git_head", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_snapshot_replay_and_cli_drift_do_not_depend_on_git_head", + "decorators": [], + "kind": "method", + "name": "test_snapshot_replay_and_cli_drift_do_not_depend_on_git_head", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_snapshot_replay_and_cli_drift_do_not_depend_on_git_head", + "signature": "def test_snapshot_replay_and_cli_drift_do_not_depend_on_git_head(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 275, + "span": { + "end": { + "byte": 18357, + "column": 109, + "line": 275 + }, + "start": { + "byte": 17438, + "column": 4, + "line": 264 + } + }, + "start_line": 264 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_snapshot_replay_and_cli_drift_do_not_depend_on_git_head", + "identity": "NativeStandardsTests.test_snapshot_replay_and_cli_drift_do_not_depend_on_git_head", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_source_discovery_reports_limits_symlinks_and_exclusions/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_source_discovery_reports_limits_symlinks_and_exclusions", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_source_discovery_reports_limits_symlinks_and_exclusions", + "decorators": [], + "kind": "method", + "name": "test_source_discovery_reports_limits_symlinks_and_exclusions", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_source_discovery_reports_limits_symlinks_and_exclusions", + "signature": "def test_source_discovery_reports_limits_symlinks_and_exclusions(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 248, + "span": { + "end": { + "byte": 16615, + "column": 50, + "line": 248 + }, + "start": { + "byte": 15711, + "column": 4, + "line": 234 + } + }, + "start_line": 234 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_source_discovery_reports_limits_symlinks_and_exclusions", + "identity": "NativeStandardsTests.test_source_discovery_reports_limits_symlinks_and_exclusions", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_source_spdx_headers_are_actual_comments/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_source_spdx_headers_are_actual_comments", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_source_spdx_headers_are_actual_comments", + "decorators": [], + "kind": "method", + "name": "test_source_spdx_headers_are_actual_comments", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_source_spdx_headers_are_actual_comments", + "signature": "def test_source_spdx_headers_are_actual_comments(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 146, + "span": { + "end": { + "byte": 8397, + "column": 104, + "line": 146 + }, + "start": { + "byte": 8144, + "column": 4, + "line": 144 + } + }, + "start_line": 144 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_source_spdx_headers_are_actual_comments", + "identity": "NativeStandardsTests.test_source_spdx_headers_are_actual_comments", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_spdx_and_cyclonedx_artifacts_preserve_native_ids/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_spdx_and_cyclonedx_artifacts_preserve_native_ids", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_spdx_and_cyclonedx_artifacts_preserve_native_ids", + "decorators": [], + "kind": "method", + "name": "test_spdx_and_cyclonedx_artifacts_preserve_native_ids", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_spdx_and_cyclonedx_artifacts_preserve_native_ids", + "signature": "def test_spdx_and_cyclonedx_artifacts_preserve_native_ids(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 183, + "span": { + "end": { + "byte": 11747, + "column": 92, + "line": 183 + }, + "start": { + "byte": 11056, + "column": 4, + "line": 178 + } + }, + "start_line": 178 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_spdx_and_cyclonedx_artifacts_preserve_native_ids", + "identity": "NativeStandardsTests.test_spdx_and_cyclonedx_artifacts_preserve_native_ids", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_typescript_multiline_members_jsdoc_tags_and_string_fences/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_typescript_multiline_members_jsdoc_tags_and_string_fences", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_typescript_multiline_members_jsdoc_tags_and_string_fences", + "decorators": [], + "kind": "method", + "name": "test_typescript_multiline_members_jsdoc_tags_and_string_fences", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_typescript_multiline_members_jsdoc_tags_and_string_fences", + "signature": "def test_typescript_multiline_members_jsdoc_tags_and_string_fences(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 118, + "span": { + "end": { + "byte": 6262, + "column": 49, + "line": 118 + }, + "start": { + "byte": 5542, + "column": 4, + "line": 98 + } + }, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_typescript_multiline_members_jsdoc_tags_and_string_fences", + "identity": "NativeStandardsTests.test_typescript_multiline_members_jsdoc_tags_and_string_fences", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_unknown_standard_versions_do_not_satisfy_required_policy/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_unknown_standard_versions_do_not_satisfy_required_policy", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_unknown_standard_versions_do_not_satisfy_required_policy", + "decorators": [], + "kind": "method", + "name": "test_unknown_standard_versions_do_not_satisfy_required_policy", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_unknown_standard_versions_do_not_satisfy_required_policy", + "signature": "def test_unknown_standard_versions_do_not_satisfy_required_policy(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 168, + "span": { + "end": { + "byte": 10250, + "column": 81, + "line": 168 + }, + "start": { + "byte": 9720, + "column": 4, + "line": 163 + } + }, + "start_line": 163 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_unknown_standard_versions_do_not_satisfy_required_policy", + "identity": "NativeStandardsTests.test_unknown_standard_versions_do_not_satisfy_required_policy", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_unsafe_or_ambiguous_serializations_are_rejected/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_unsafe_or_ambiguous_serializations_are_rejected", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_unsafe_or_ambiguous_serializations_are_rejected", + "decorators": [], + "kind": "method", + "name": "test_unsafe_or_ambiguous_serializations_are_rejected", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_unsafe_or_ambiguous_serializations_are_rejected", + "signature": "def test_unsafe_or_ambiguous_serializations_are_rejected(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 58, + "span": { + "end": { + "byte": 2728, + "column": 65, + "line": 58 + }, + "start": { + "byte": 2103, + "column": 4, + "line": 50 + } + }, + "start_line": 50 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_unsafe_or_ambiguous_serializations_are_rejected", + "identity": "NativeStandardsTests.test_unsafe_or_ambiguous_serializations_are_rejected", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_yaml_core_nested_aliases_and_typed_keys_are_preserved/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "NativeStandardsTests.test_yaml_core_nested_aliases_and_typed_keys_are_preserved", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::method:NativeStandardsTests.test_yaml_core_nested_aliases_and_typed_keys_are_preserved", + "decorators": [], + "kind": "method", + "name": "test_yaml_core_nested_aliases_and_typed_keys_are_preserved", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "qualified_name": "NativeStandardsTests.test_yaml_core_nested_aliases_and_typed_keys_are_preserved", + "signature": "def test_yaml_core_nested_aliases_and_typed_keys_are_preserved(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 48, + "span": { + "end": { + "byte": 2097, + "column": 79, + "line": 48 + }, + "start": { + "byte": 1445, + "column": 4, + "line": 40 + } + }, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests.test_yaml_core_nested_aliases_and_typed_keys_are_preserved", + "identity": "NativeStandardsTests.test_yaml_core_nested_aliases_and_typed_keys_are_preserved", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "NativeStandardsTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_native_standards.py::class:NativeStandardsTests", + "decorators": [], + "kind": "class", + "name": "NativeStandardsTests", + "parent_identity": null, + "qualified_name": "NativeStandardsTests", + "signature": "class NativeStandardsTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "329e719a8b9b02159915223b7d62420541c8981036683de0f0e2453f46ac914a", + "file": "tests/test_native_standards.py", + "location": { + "end_line": 275, + "span": { + "end": { + "byte": 18357, + "column": 109, + "line": 275 + }, + "start": { + "byte": 701, + "column": 0, + "line": 26 + } + }, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_native_standards.py#subject/symbol/NativeStandardsTests", + "identity": "NativeStandardsTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "40:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A161-161/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "40:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 161, + "start_line": 161 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "7:2" + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A161-161/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "7:2" + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 161, + "start_line": 161 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "70:34" + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A161-161/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "70:34" + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 161, + "start_line": 161 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=70:34 imports_exports=7:2 calls_definitions=40:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 71, + "column": 71, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::<module>", + "metadata_kind": "comment", + "text": "noqa: E402" + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 14, + "span": { + "end": { + "byte": 376, + "column": 46, + "line": 14 + }, + "start": { + "byte": 364, + "column": 34, + "line": 14 + } + }, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::<module>", + "metadata_kind": "comment", + "text": "noqa: E402" + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 15, + "span": { + "end": { + "byte": 425, + "column": 48, + "line": 15 + }, + "start": { + "byte": 413, + "column": 36, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CHECKS ===\nid: check_org_rec_append_only\n proves: org_rec_append_only\n call: self::test_aggregate_append_preserves_existing_content\n requires: python3, posix_shell\n timeout: 5\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_org_rec_missing_repo_visible\n proves: org_rec_missing_repo_visible\n call: self::test_aggregate_lists_missing_rec_files\n requires: python3, posix_shell\n timeout: 5\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_org_rec_remaining_fallback\n proves: org_rec_remaining_fallback\n call: self::test_aggregate_uses_remaining_when_latest_block_has_no_recommendations\n requires: python3, posix_shell\n timeout: 5\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_org_ratio_skips_vendored_skills\n proves: org_ratio_skips_vendored_skills\n call: self::test_ratio_metrics_skip_vendored_agents\n requires: python3, posix_shell\n timeout: 5\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_org_ratio_oddities_visible\n proves: org_ratio_oddities_visible\n call: self::test_ratio_report_lists_low_coverage_oddity\n requires: python3, posix_shell\n timeout: 5\n mutates: filesystem\n cleanup: tempdir_teardown\n=== END CHECKS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 57, + "span": { + "end": { + "byte": 1705, + "column": 20, + "line": 57 + }, + "start": { + "byte": 427, + "column": 0, + "line": 17 + } + }, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=70:34 imports_exports=7:2 calls_definitions=40:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 161, + "span": { + "end": { + "byte": 5982, + "column": 71, + "line": 161 + }, + "start": { + "byte": 5911, + "column": 0, + "line": 161 + } + }, + "start_line": 161 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Tests for org-wide recommendation and ratio report runners.", + "text": "Tests for org-wide recommendation and ratio report runners." + } + }, + "origin": "native", + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 2, + "span": { + "end": { + "byte": 137, + "column": 65, + "line": 2 + }, + "start": { + "byte": 72, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "aggregate_org_rec:aggregate_org_rec:5", + "value": { + "alias": "recs", + "kind": "import", + "level": 0, + "module": "aggregate_org_rec", + "name": "aggregate_org_rec" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "org_ratio_compare:org_ratio_compare:6", + "value": { + "alias": "ratios", + "kind": "import", + "level": 0, + "module": "org_ratio_compare", + "name": "org_ratio_compare" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/module/tests%2Ftest_org_reports.py", + "identity": "tests/test_org_reports.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRatioReportTests.test_ratio_dirty_status_ignores_report_files/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "OrgRatioReportTests.test_ratio_dirty_status_ignores_report_files", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::method:OrgRatioReportTests.test_ratio_dirty_status_ignores_report_files", + "decorators": [], + "kind": "method", + "name": "test_ratio_dirty_status_ignores_report_files", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::class:OrgRatioReportTests", + "qualified_name": "OrgRatioReportTests.test_ratio_dirty_status_ignores_report_files", + "signature": "def test_ratio_dirty_status_ignores_report_files(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 143, + "span": { + "end": { + "byte": 5250, + "column": 63, + "line": 143 + }, + "start": { + "byte": 5057, + "column": 4, + "line": 140 + } + }, + "start_line": 140 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRatioReportTests.test_ratio_dirty_status_ignores_report_files", + "identity": "OrgRatioReportTests.test_ratio_dirty_status_ignores_report_files", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRatioReportTests.test_ratio_metrics_skip_vendored_agents/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "OrgRatioReportTests.test_ratio_metrics_skip_vendored_agents", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::method:OrgRatioReportTests.test_ratio_metrics_skip_vendored_agents", + "decorators": [], + "kind": "method", + "name": "test_ratio_metrics_skip_vendored_agents", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::class:OrgRatioReportTests", + "qualified_name": "OrgRatioReportTests.test_ratio_metrics_skip_vendored_agents", + "signature": "def test_ratio_metrics_skip_vendored_agents(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 138, + "span": { + "end": { + "byte": 5051, + "column": 59, + "line": 138 + }, + "start": { + "byte": 4217, + "column": 4, + "line": 121 + } + }, + "start_line": 121 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRatioReportTests.test_ratio_metrics_skip_vendored_agents", + "identity": "OrgRatioReportTests.test_ratio_metrics_skip_vendored_agents", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRatioReportTests.test_ratio_report_lists_low_coverage_oddity/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "OrgRatioReportTests.test_ratio_report_lists_low_coverage_oddity", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::method:OrgRatioReportTests.test_ratio_report_lists_low_coverage_oddity", + "decorators": [], + "kind": "method", + "name": "test_ratio_report_lists_low_coverage_oddity", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::class:OrgRatioReportTests", + "qualified_name": "OrgRatioReportTests.test_ratio_report_lists_low_coverage_oddity", + "signature": "def test_ratio_report_lists_low_coverage_oddity(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 156, + "span": { + "end": { + "byte": 5861, + "column": 80, + "line": 156 + }, + "start": { + "byte": 5256, + "column": 4, + "line": 145 + } + }, + "start_line": 145 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRatioReportTests.test_ratio_report_lists_low_coverage_oddity", + "identity": "OrgRatioReportTests.test_ratio_report_lists_low_coverage_oddity", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRatioReportTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "OrgRatioReportTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::class:OrgRatioReportTests", + "decorators": [], + "kind": "class", + "name": "OrgRatioReportTests", + "parent_identity": null, + "qualified_name": "OrgRatioReportTests", + "signature": "class OrgRatioReportTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 156, + "span": { + "end": { + "byte": 5861, + "column": 80, + "line": 156 + }, + "start": { + "byte": 4167, + "column": 0, + "line": 120 + } + }, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRatioReportTests", + "identity": "OrgRatioReportTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRecommendationReportTests.test_aggregate_append_preserves_existing_content/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "OrgRecommendationReportTests.test_aggregate_append_preserves_existing_content", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::method:OrgRecommendationReportTests.test_aggregate_append_preserves_existing_content", + "decorators": [], + "kind": "method", + "name": "test_aggregate_append_preserves_existing_content", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::class:OrgRecommendationReportTests", + "qualified_name": "OrgRecommendationReportTests.test_aggregate_append_preserves_existing_content", + "signature": "def test_aggregate_append_preserves_existing_content(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 83, + "span": { + "end": { + "byte": 2760, + "column": 59, + "line": 83 + }, + "start": { + "byte": 1767, + "column": 4, + "line": 61 + } + }, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRecommendationReportTests.test_aggregate_append_preserves_existing_content", + "identity": "OrgRecommendationReportTests.test_aggregate_append_preserves_existing_content", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRecommendationReportTests.test_aggregate_lists_missing_rec_files/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "OrgRecommendationReportTests.test_aggregate_lists_missing_rec_files", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::method:OrgRecommendationReportTests.test_aggregate_lists_missing_rec_files", + "decorators": [], + "kind": "method", + "name": "test_aggregate_lists_missing_rec_files", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::class:OrgRecommendationReportTests", + "qualified_name": "OrgRecommendationReportTests.test_aggregate_lists_missing_rec_files", + "signature": "def test_aggregate_lists_missing_rec_files(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 93, + "span": { + "end": { + "byte": 3213, + "column": 88, + "line": 93 + }, + "start": { + "byte": 2766, + "column": 4, + "line": 85 + } + }, + "start_line": 85 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRecommendationReportTests.test_aggregate_lists_missing_rec_files", + "identity": "OrgRecommendationReportTests.test_aggregate_lists_missing_rec_files", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRecommendationReportTests.test_aggregate_uses_remaining_when_latest_block_has_no_recommendations/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "OrgRecommendationReportTests.test_aggregate_uses_remaining_when_latest_block_has_no_recommendations", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::method:OrgRecommendationReportTests.test_aggregate_uses_remaining_when_latest_block_has_no_recommendations", + "decorators": [], + "kind": "method", + "name": "test_aggregate_uses_remaining_when_latest_block_has_no_recommendations", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::class:OrgRecommendationReportTests", + "qualified_name": "OrgRecommendationReportTests.test_aggregate_uses_remaining_when_latest_block_has_no_recommendations", + "signature": "def test_aggregate_uses_remaining_when_latest_block_has_no_recommendations(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 117, + "span": { + "end": { + "byte": 4164, + "column": 58, + "line": 117 + }, + "start": { + "byte": 3219, + "column": 4, + "line": 95 + } + }, + "start_line": 95 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRecommendationReportTests.test_aggregate_uses_remaining_when_latest_block_has_no_recommendations", + "identity": "OrgRecommendationReportTests.test_aggregate_uses_remaining_when_latest_block_has_no_recommendations", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRecommendationReportTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "OrgRecommendationReportTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_org_reports.py::class:OrgRecommendationReportTests", + "decorators": [], + "kind": "class", + "name": "OrgRecommendationReportTests", + "parent_identity": null, + "qualified_name": "OrgRecommendationReportTests", + "signature": "class OrgRecommendationReportTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a22853ca8d9f4c6cbfd6bb2d4d7d895dff60d6674184c01a9bb29d3505e48325", + "file": "tests/test_org_reports.py", + "location": { + "end_line": 117, + "span": { + "end": { + "byte": 4164, + "column": 58, + "line": 117 + }, + "start": { + "byte": 1708, + "column": 0, + "line": 60 + } + }, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_org_reports.py#subject/symbol/OrgRecommendationReportTests", + "identity": "OrgRecommendationReportTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py", + "identity": "tests/test_project_incubation_graduation_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py", + "identity": "tests/test_project_incubation_graduation_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py", + "identity": "tests/test_project_incubation_graduation_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py", + "identity": "tests/test_project_incubation_graduation_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "frontmatter:frontmatter_for:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "frontmatter", + "name": "frontmatter_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/module/tests%2Ftest_project_incubation_graduation_skill.py", + "identity": "tests/test_project_incubation_graduation_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ProjectIncubationGraduationSkillTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::method:ProjectIncubationGraduationSkillTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::class:ProjectIncubationGraduationSkillTest", + "qualified_name": "ProjectIncubationGraduationSkillTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 21, + "span": { + "end": { + "byte": 660, + "column": 58, + "line": 21 + }, + "start": { + "byte": 406, + "column": 4, + "line": 17 + } + }, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.setUp", + "identity": "ProjectIncubationGraduationSkillTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_activation_and_non_trigger_are_explicit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ProjectIncubationGraduationSkillTest.test_activation_and_non_trigger_are_explicit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::method:ProjectIncubationGraduationSkillTest.test_activation_and_non_trigger_are_explicit", + "decorators": [], + "kind": "method", + "name": "test_activation_and_non_trigger_are_explicit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::class:ProjectIncubationGraduationSkillTest", + "qualified_name": "ProjectIncubationGraduationSkillTest.test_activation_and_non_trigger_are_explicit", + "signature": "def test_activation_and_non_trigger_are_explicit(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 32, + "span": { + "end": { + "byte": 1327, + "column": 61, + "line": 32 + }, + "start": { + "byte": 666, + "column": 4, + "line": 23 + } + }, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_activation_and_non_trigger_are_explicit", + "identity": "ProjectIncubationGraduationSkillTest.test_activation_and_non_trigger_are_explicit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_artifact_identity_is_immutable_not_version_only/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ProjectIncubationGraduationSkillTest.test_artifact_identity_is_immutable_not_version_only", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::method:ProjectIncubationGraduationSkillTest.test_artifact_identity_is_immutable_not_version_only", + "decorators": [], + "kind": "method", + "name": "test_artifact_identity_is_immutable_not_version_only", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::class:ProjectIncubationGraduationSkillTest", + "qualified_name": "ProjectIncubationGraduationSkillTest.test_artifact_identity_is_immutable_not_version_only", + "signature": "def test_artifact_identity_is_immutable_not_version_only(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 95, + "span": { + "end": { + "byte": 4671, + "column": 83, + "line": 95 + }, + "start": { + "byte": 4147, + "column": 4, + "line": 89 + } + }, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_artifact_identity_is_immutable_not_version_only", + "identity": "ProjectIncubationGraduationSkillTest.test_artifact_identity_is_immutable_not_version_only", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_authority_transition_is_scoped_between_work_graph_snapshots/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ProjectIncubationGraduationSkillTest.test_authority_transition_is_scoped_between_work_graph_snapshots", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::method:ProjectIncubationGraduationSkillTest.test_authority_transition_is_scoped_between_work_graph_snapshots", + "decorators": [], + "kind": "method", + "name": "test_authority_transition_is_scoped_between_work_graph_snapshots", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::class:ProjectIncubationGraduationSkillTest", + "qualified_name": "ProjectIncubationGraduationSkillTest.test_authority_transition_is_scoped_between_work_graph_snapshots", + "signature": "def test_authority_transition_is_scoped_between_work_graph_snapshots(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 113, + "span": { + "end": { + "byte": 5660, + "column": 53, + "line": 113 + }, + "start": { + "byte": 4677, + "column": 4, + "line": 97 + } + }, + "start_line": 97 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_authority_transition_is_scoped_between_work_graph_snapshots", + "identity": "ProjectIncubationGraduationSkillTest.test_authority_transition_is_scoped_between_work_graph_snapshots", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_exact_candidate_is_verified_before_stable_publication/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ProjectIncubationGraduationSkillTest.test_exact_candidate_is_verified_before_stable_publication", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::method:ProjectIncubationGraduationSkillTest.test_exact_candidate_is_verified_before_stable_publication", + "decorators": [], + "kind": "method", + "name": "test_exact_candidate_is_verified_before_stable_publication", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::class:ProjectIncubationGraduationSkillTest", + "qualified_name": "ProjectIncubationGraduationSkillTest.test_exact_candidate_is_verified_before_stable_publication", + "signature": "def test_exact_candidate_is_verified_before_stable_publication(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 87, + "span": { + "end": { + "byte": 4141, + "column": 80, + "line": 87 + }, + "start": { + "byte": 3637, + "column": 4, + "line": 82 + } + }, + "start_line": 82 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_exact_candidate_is_verified_before_stable_publication", + "identity": "ProjectIncubationGraduationSkillTest.test_exact_candidate_is_verified_before_stable_publication", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_external_mutations_require_explicit_authorization/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ProjectIncubationGraduationSkillTest.test_external_mutations_require_explicit_authorization", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::method:ProjectIncubationGraduationSkillTest.test_external_mutations_require_explicit_authorization", + "decorators": [], + "kind": "method", + "name": "test_external_mutations_require_explicit_authorization", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::class:ProjectIncubationGraduationSkillTest", + "qualified_name": "ProjectIncubationGraduationSkillTest.test_external_mutations_require_explicit_authorization", + "signature": "def test_external_mutations_require_explicit_authorization(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 73, + "span": { + "end": { + "byte": 3202, + "column": 48, + "line": 73 + }, + "start": { + "byte": 2507, + "column": 4, + "line": 60 + } + }, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_external_mutations_require_explicit_authorization", + "identity": "ProjectIncubationGraduationSkillTest.test_external_mutations_require_explicit_authorization", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_hmmm_remains_visible_but_blocking_unknowns_do_not_pass/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ProjectIncubationGraduationSkillTest.test_hmmm_remains_visible_but_blocking_unknowns_do_not_pass", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::method:ProjectIncubationGraduationSkillTest.test_hmmm_remains_visible_but_blocking_unknowns_do_not_pass", + "decorators": [], + "kind": "method", + "name": "test_hmmm_remains_visible_but_blocking_unknowns_do_not_pass", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::class:ProjectIncubationGraduationSkillTest", + "qualified_name": "ProjectIncubationGraduationSkillTest.test_hmmm_remains_visible_but_blocking_unknowns_do_not_pass", + "signature": "def test_hmmm_remains_visible_but_blocking_unknowns_do_not_pass(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 118, + "span": { + "end": { + "byte": 5956, + "column": 76, + "line": 118 + }, + "start": { + "byte": 5666, + "column": 4, + "line": 115 + } + }, + "start_line": 115 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_hmmm_remains_visible_but_blocking_unknowns_do_not_pass", + "identity": "ProjectIncubationGraduationSkillTest.test_hmmm_remains_visible_but_blocking_unknowns_do_not_pass", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_lifecycle_and_reconsumption_gate_are_explicit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ProjectIncubationGraduationSkillTest.test_lifecycle_and_reconsumption_gate_are_explicit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::method:ProjectIncubationGraduationSkillTest.test_lifecycle_and_reconsumption_gate_are_explicit", + "decorators": [], + "kind": "method", + "name": "test_lifecycle_and_reconsumption_gate_are_explicit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::class:ProjectIncubationGraduationSkillTest", + "qualified_name": "ProjectIncubationGraduationSkillTest.test_lifecycle_and_reconsumption_gate_are_explicit", + "signature": "def test_lifecycle_and_reconsumption_gate_are_explicit(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 58, + "span": { + "end": { + "byte": 2501, + "column": 90, + "line": 58 + }, + "start": { + "byte": 1891, + "column": 4, + "line": 44 + } + }, + "start_line": 44 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_lifecycle_and_reconsumption_gate_are_explicit", + "identity": "ProjectIncubationGraduationSkillTest.test_lifecycle_and_reconsumption_gate_are_explicit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_registered_as_procedural_and_adapter_loads_canonical_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ProjectIncubationGraduationSkillTest.test_registered_as_procedural_and_adapter_loads_canonical_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::method:ProjectIncubationGraduationSkillTest.test_registered_as_procedural_and_adapter_loads_canonical_skill", + "decorators": [], + "kind": "method", + "name": "test_registered_as_procedural_and_adapter_loads_canonical_skill", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::class:ProjectIncubationGraduationSkillTest", + "qualified_name": "ProjectIncubationGraduationSkillTest.test_registered_as_procedural_and_adapter_loads_canonical_skill", + "signature": "def test_registered_as_procedural_and_adapter_loads_canonical_skill(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 42, + "span": { + "end": { + "byte": 1885, + "column": 101, + "line": 42 + }, + "start": { + "byte": 1333, + "column": 4, + "line": 34 + } + }, + "start_line": 34 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_registered_as_procedural_and_adapter_loads_canonical_skill", + "identity": "ProjectIncubationGraduationSkillTest.test_registered_as_procedural_and_adapter_loads_canonical_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_release_authority_unknowns_block_qualification/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ProjectIncubationGraduationSkillTest.test_release_authority_unknowns_block_qualification", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::method:ProjectIncubationGraduationSkillTest.test_release_authority_unknowns_block_qualification", + "decorators": [], + "kind": "method", + "name": "test_release_authority_unknowns_block_qualification", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::class:ProjectIncubationGraduationSkillTest", + "qualified_name": "ProjectIncubationGraduationSkillTest.test_release_authority_unknowns_block_qualification", + "signature": "def test_release_authority_unknowns_block_qualification(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 80, + "span": { + "end": { + "byte": 3631, + "column": 110, + "line": 80 + }, + "start": { + "byte": 3208, + "column": 4, + "line": 75 + } + }, + "start_line": 75 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest.test_release_authority_unknowns_block_qualification", + "identity": "ProjectIncubationGraduationSkillTest.test_release_authority_unknowns_block_qualification", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "ProjectIncubationGraduationSkillTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_project_incubation_graduation_skill.py::class:ProjectIncubationGraduationSkillTest", + "decorators": [], + "kind": "class", + "name": "ProjectIncubationGraduationSkillTest", + "parent_identity": null, + "qualified_name": "ProjectIncubationGraduationSkillTest", + "signature": "class ProjectIncubationGraduationSkillTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8b7d1f69407d5d9091deb55fdf84a4c0618d03c2a07197cdad70c88398238f9c", + "file": "tests/test_project_incubation_graduation_skill.py", + "location": { + "end_line": 118, + "span": { + "end": { + "byte": 5956, + "column": 76, + "line": 118 + }, + "start": { + "byte": 339, + "column": 0, + "line": 16 + } + }, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_project_incubation_graduation_skill.py#subject/symbol/ProjectIncubationGraduationSkillTest", + "identity": "ProjectIncubationGraduationSkillTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "identity": "tests/test_propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "importlib.util:importlib.util:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "importlib.util", + "name": "importlib.util" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "identity": "tests/test_propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "identity": "tests/test_propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "identity": "tests/test_propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "identity": "tests/test_propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "identity": "tests/test_propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest.mock:patch:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "unittest.mock", + "name": "patch" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/module/tests%2Ftest_propagate_skills.py", + "identity": "tests/test_propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_apply_carries_referenced_doctrine/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PropagateDoctrineTest.test_apply_carries_referenced_doctrine", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::method:PropagateDoctrineTest.test_apply_carries_referenced_doctrine", + "decorators": [], + "kind": "method", + "name": "test_apply_carries_referenced_doctrine", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::class:PropagateDoctrineTest", + "qualified_name": "PropagateDoctrineTest.test_apply_carries_referenced_doctrine", + "signature": "def test_apply_carries_referenced_doctrine(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 90, + "span": { + "end": { + "byte": 4432, + "column": 100, + "line": 90 + }, + "start": { + "byte": 3890, + "column": 4, + "line": 83 + } + }, + "start_line": 83 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_apply_carries_referenced_doctrine", + "identity": "PropagateDoctrineTest.test_apply_carries_referenced_doctrine", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_apply_removes_superseded_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PropagateDoctrineTest.test_apply_removes_superseded_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::method:PropagateDoctrineTest.test_apply_removes_superseded_skill", + "decorators": [], + "kind": "method", + "name": "test_apply_removes_superseded_skill", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::class:PropagateDoctrineTest", + "qualified_name": "PropagateDoctrineTest.test_apply_removes_superseded_skill", + "signature": "def test_apply_removes_superseded_skill(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 110, + "span": { + "end": { + "byte": 5326, + "column": 87, + "line": 110 + }, + "start": { + "byte": 4750, + "column": 4, + "line": 99 + } + }, + "start_line": 99 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_apply_removes_superseded_skill", + "identity": "PropagateDoctrineTest.test_apply_removes_superseded_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_dry_run_writes_nothing/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::method:PropagateDoctrineTest.test_dry_run_writes_nothing", + "metadata_kind": "comment", + "text": "no --apply" + } + }, + "origin": "native", + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 95, + "span": { + "end": { + "byte": 4641, + "column": 74, + "line": 95 + }, + "start": { + "byte": 4629, + "column": 62, + "line": 95 + } + }, + "start_line": 95 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_dry_run_writes_nothing", + "identity": "PropagateDoctrineTest.test_dry_run_writes_nothing", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_dry_run_writes_nothing/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PropagateDoctrineTest.test_dry_run_writes_nothing", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::method:PropagateDoctrineTest.test_dry_run_writes_nothing", + "decorators": [], + "kind": "method", + "name": "test_dry_run_writes_nothing", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::class:PropagateDoctrineTest", + "qualified_name": "PropagateDoctrineTest.test_dry_run_writes_nothing", + "signature": "def test_dry_run_writes_nothing(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 97, + "span": { + "end": { + "byte": 4744, + "column": 66, + "line": 97 + }, + "start": { + "byte": 4438, + "column": 4, + "line": 92 + } + }, + "start_line": 92 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_dry_run_writes_nothing", + "identity": "PropagateDoctrineTest.test_dry_run_writes_nothing", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_partial_refresh_preserves_explicitly_unknown_skill_source/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PropagateDoctrineTest.test_partial_refresh_preserves_explicitly_unknown_skill_source", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::method:PropagateDoctrineTest.test_partial_refresh_preserves_explicitly_unknown_skill_source", + "decorators": [], + "kind": "method", + "name": "test_partial_refresh_preserves_explicitly_unknown_skill_source", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::class:PropagateDoctrineTest", + "qualified_name": "PropagateDoctrineTest.test_partial_refresh_preserves_explicitly_unknown_skill_source", + "signature": "def test_partial_refresh_preserves_explicitly_unknown_skill_source(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 76, + "span": { + "end": { + "byte": 3642, + "column": 53, + "line": 76 + }, + "start": { + "byte": 2613, + "column": 4, + "line": 58 + } + }, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_partial_refresh_preserves_explicitly_unknown_skill_source", + "identity": "PropagateDoctrineTest.test_partial_refresh_preserves_explicitly_unknown_skill_source", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_partial_refresh_preserves_local_skill_index_and_description/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PropagateDoctrineTest.test_partial_refresh_preserves_local_skill_index_and_description", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::method:PropagateDoctrineTest.test_partial_refresh_preserves_local_skill_index_and_description", + "decorators": [], + "kind": "method", + "name": "test_partial_refresh_preserves_local_skill_index_and_description", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::class:PropagateDoctrineTest", + "qualified_name": "PropagateDoctrineTest.test_partial_refresh_preserves_local_skill_index_and_description", + "signature": "def test_partial_refresh_preserves_local_skill_index_and_description(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 36, + "span": { + "end": { + "byte": 1566, + "column": 98, + "line": 36 + }, + "start": { + "byte": 471, + "column": 4, + "line": 20 + } + }, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_partial_refresh_preserves_local_skill_index_and_description", + "identity": "PropagateDoctrineTest.test_partial_refresh_preserves_local_skill_index_and_description", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_partial_refresh_uses_annotated_skill_prior_source/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PropagateDoctrineTest.test_partial_refresh_uses_annotated_skill_prior_source", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::method:PropagateDoctrineTest.test_partial_refresh_uses_annotated_skill_prior_source", + "decorators": [], + "kind": "method", + "name": "test_partial_refresh_uses_annotated_skill_prior_source", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::class:PropagateDoctrineTest", + "qualified_name": "PropagateDoctrineTest.test_partial_refresh_uses_annotated_skill_prior_source", + "signature": "def test_partial_refresh_uses_annotated_skill_prior_source(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 56, + "span": { + "end": { + "byte": 2607, + "column": 63, + "line": 56 + }, + "start": { + "byte": 1572, + "column": 4, + "line": 38 + } + }, + "start_line": 38 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_partial_refresh_uses_annotated_skill_prior_source", + "identity": "PropagateDoctrineTest.test_partial_refresh_uses_annotated_skill_prior_source", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_referenced_doctrine_helper_finds_link/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::method:PropagateDoctrineTest.test_referenced_doctrine_helper_finds_link", + "metadata_kind": "comment", + "text": "canonical msdmd/SKILL.md links to ../doctrine/msdmd-checks.md" + } + }, + "origin": "native", + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 79, + "span": { + "end": { + "byte": 3781, + "column": 71, + "line": 79 + }, + "start": { + "byte": 3718, + "column": 8, + "line": 79 + } + }, + "start_line": 79 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_referenced_doctrine_helper_finds_link", + "identity": "PropagateDoctrineTest.test_referenced_doctrine_helper_finds_link", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_referenced_doctrine_helper_finds_link/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PropagateDoctrineTest.test_referenced_doctrine_helper_finds_link", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::method:PropagateDoctrineTest.test_referenced_doctrine_helper_finds_link", + "decorators": [], + "kind": "method", + "name": "test_referenced_doctrine_helper_finds_link", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::class:PropagateDoctrineTest", + "qualified_name": "PropagateDoctrineTest.test_referenced_doctrine_helper_finds_link", + "signature": "def test_referenced_doctrine_helper_finds_link(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 81, + "span": { + "end": { + "byte": 3884, + "column": 46, + "line": 81 + }, + "start": { + "byte": 3648, + "column": 4, + "line": 78 + } + }, + "start_line": 78 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_referenced_doctrine_helper_finds_link", + "identity": "PropagateDoctrineTest.test_referenced_doctrine_helper_finds_link", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files.prior_blob/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files.prior_blob", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::function:PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files.prior_blob", + "decorators": [], + "kind": "function", + "name": "prior_blob", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::method:PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files", + "qualified_name": "PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files.prior_blob", + "signature": "def prior_blob(_sha: str, _skill: str, path: Path) -> bytes | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 125, + "span": { + "end": { + "byte": 6117, + "column": 78, + "line": 125 + }, + "start": { + "byte": 5971, + "column": 12, + "line": 124 + } + }, + "start_line": 124 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files.prior_blob", + "identity": "PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files.prior_blob", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::method:PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files", + "decorators": [], + "kind": "method", + "name": "test_sync_preserves_local_additions_and_removes_proven_obsolete_files", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::class:PropagateDoctrineTest", + "qualified_name": "PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files", + "signature": "def test_sync_preserves_local_additions_and_removes_proven_obsolete_files(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 133, + "span": { + "end": { + "byte": 6566, + "column": 60, + "line": 133 + }, + "start": { + "byte": 5332, + "column": 4, + "line": 112 + } + }, + "start_line": 112 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files", + "identity": "PropagateDoctrineTest.test_sync_preserves_local_additions_and_removes_proven_obsolete_files", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "PropagateDoctrineTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_propagate_skills.py::class:PropagateDoctrineTest", + "decorators": [], + "kind": "class", + "name": "PropagateDoctrineTest", + "parent_identity": null, + "qualified_name": "PropagateDoctrineTest", + "signature": "class PropagateDoctrineTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a99bd295ae7c519b54b16c18de3da56f8740dd3d750fdf3d7b06ece8c0e70459", + "file": "tests/test_propagate_skills.py", + "location": { + "end_line": 133, + "span": { + "end": { + "byte": 6566, + "column": 60, + "line": 133 + }, + "start": { + "byte": 419, + "column": 0, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_propagate_skills.py#subject/symbol/PropagateDoctrineTest", + "identity": "PropagateDoctrineTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ratios_check.py::<module>", + "metadata_kind": "comment", + "text": "noqa: E402" + } + }, + "origin": "native", + "source": { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "file": "tests/test_ratios_check.py", + "location": { + "end_line": 11, + "span": { + "end": { + "byte": 232, + "column": 38, + "line": 11 + }, + "start": { + "byte": 220, + "column": 26, + "line": 11 + } + }, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "identity": "tests/test_ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "file": "tests/test_ratios_check.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "identity": "tests/test_ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "file": "tests/test_ratios_check.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "identity": "tests/test_ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "file": "tests/test_ratios_check.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "identity": "tests/test_ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "file": "tests/test_ratios_check.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "identity": "tests/test_ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "file": "tests/test_ratios_check.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "identity": "tests/test_ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "ratios_check:ratios_check:5", + "value": { + "alias": "R", + "kind": "import", + "level": 0, + "module": "ratios_check", + "name": "ratios_check" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "file": "tests/test_ratios_check.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/module/tests%2Ftest_ratios_check.py", + "identity": "tests/test_ratios_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/symbol/RatiosCheckScopeTest.test_annotated_non_python_ratios_remain_visible_but_unverified/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RatiosCheckScopeTest.test_annotated_non_python_ratios_remain_visible_but_unverified", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ratios_check.py::method:RatiosCheckScopeTest.test_annotated_non_python_ratios_remain_visible_but_unverified", + "decorators": [], + "kind": "method", + "name": "test_annotated_non_python_ratios_remain_visible_but_unverified", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ratios_check.py::class:RatiosCheckScopeTest", + "qualified_name": "RatiosCheckScopeTest.test_annotated_non_python_ratios_remain_visible_but_unverified", + "signature": "def test_annotated_non_python_ratios_remain_visible_but_unverified(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "file": "tests/test_ratios_check.py", + "location": { + "end_line": 49, + "span": { + "end": { + "byte": 1871, + "column": 13, + "line": 49 + }, + "start": { + "byte": 1057, + "column": 4, + "line": 33 + } + }, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/symbol/RatiosCheckScopeTest.test_annotated_non_python_ratios_remain_visible_but_unverified", + "identity": "RatiosCheckScopeTest.test_annotated_non_python_ratios_remain_visible_but_unverified", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/symbol/RatiosCheckScopeTest.test_parser_language_support_does_not_create_false_ratio_gaps/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RatiosCheckScopeTest.test_parser_language_support_does_not_create_false_ratio_gaps", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ratios_check.py::method:RatiosCheckScopeTest.test_parser_language_support_does_not_create_false_ratio_gaps", + "decorators": [], + "kind": "method", + "name": "test_parser_language_support_does_not_create_false_ratio_gaps", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ratios_check.py::class:RatiosCheckScopeTest", + "qualified_name": "RatiosCheckScopeTest.test_parser_language_support_does_not_create_false_ratio_gaps", + "signature": "def test_parser_language_support_does_not_create_false_ratio_gaps(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "file": "tests/test_ratios_check.py", + "location": { + "end_line": 31, + "span": { + "end": { + "byte": 1051, + "column": 74, + "line": 31 + }, + "start": { + "byte": 286, + "column": 4, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/symbol/RatiosCheckScopeTest.test_parser_language_support_does_not_create_false_ratio_gaps", + "identity": "RatiosCheckScopeTest.test_parser_language_support_does_not_create_false_ratio_gaps", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/symbol/RatiosCheckScopeTest.test_shebang_is_the_only_allowed_opening_preamble/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RatiosCheckScopeTest.test_shebang_is_the_only_allowed_opening_preamble", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ratios_check.py::method:RatiosCheckScopeTest.test_shebang_is_the_only_allowed_opening_preamble", + "decorators": [], + "kind": "method", + "name": "test_shebang_is_the_only_allowed_opening_preamble", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ratios_check.py::class:RatiosCheckScopeTest", + "qualified_name": "RatiosCheckScopeTest.test_shebang_is_the_only_allowed_opening_preamble", + "signature": "def test_shebang_is_the_only_allowed_opening_preamble(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "file": "tests/test_ratios_check.py", + "location": { + "end_line": 74, + "span": { + "end": { + "byte": 2823, + "column": 13, + "line": 74 + }, + "start": { + "byte": 1877, + "column": 4, + "line": 51 + } + }, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/symbol/RatiosCheckScopeTest.test_shebang_is_the_only_allowed_opening_preamble", + "identity": "RatiosCheckScopeTest.test_shebang_is_the_only_allowed_opening_preamble", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/symbol/RatiosCheckScopeTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "RatiosCheckScopeTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ratios_check.py::class:RatiosCheckScopeTest", + "decorators": [], + "kind": "class", + "name": "RatiosCheckScopeTest", + "parent_identity": null, + "qualified_name": "RatiosCheckScopeTest", + "signature": "class RatiosCheckScopeTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "d3dfc94165560bca6589db3423d3212d69871e2ac44574175dcd68e54efa7cf8", + "file": "tests/test_ratios_check.py", + "location": { + "end_line": 74, + "span": { + "end": { + "byte": 2823, + "column": 13, + "line": 74 + }, + "start": { + "byte": 235, + "column": 0, + "line": 14 + } + }, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ratios_check.py#subject/symbol/RatiosCheckScopeTest", + "identity": "RatiosCheckScopeTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py", + "identity": "tests/test_repo_audit_repair_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py", + "identity": "tests/test_repo_audit_repair_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py", + "identity": "tests/test_repo_audit_repair_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py", + "identity": "tests/test_repo_audit_repair_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "frontmatter:frontmatter_for:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "frontmatter", + "name": "frontmatter_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/module/tests%2Ftest_repo_audit_repair_skill.py", + "identity": "tests/test_repo_audit_repair_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.setUpClass/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoAuditRepairSkillTest.setUpClass", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::method:RepoAuditRepairSkillTest.setUpClass", + "decorators": [ + "classmethod" + ], + "kind": "method", + "name": "setUpClass", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "qualified_name": "RepoAuditRepairSkillTest.setUpClass", + "signature": "def setUpClass(cls) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 19, + "span": { + "end": { + "byte": 549, + "column": 63, + "line": 19 + }, + "start": { + "byte": 335, + "column": 4, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.setUpClass", + "identity": "RepoAuditRepairSkillTest.setUpClass", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_activation_is_broad_audit_not_ordinary_edit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoAuditRepairSkillTest.test_activation_is_broad_audit_not_ordinary_edit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::method:RepoAuditRepairSkillTest.test_activation_is_broad_audit_not_ordinary_edit", + "decorators": [], + "kind": "method", + "name": "test_activation_is_broad_audit_not_ordinary_edit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "qualified_name": "RepoAuditRepairSkillTest.test_activation_is_broad_audit_not_ordinary_edit", + "signature": "def test_activation_is_broad_audit_not_ordinary_edit(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 23, + "span": { + "end": { + "byte": 798, + "column": 87, + "line": 23 + }, + "start": { + "byte": 555, + "column": 4, + "line": 21 + } + }, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_activation_is_broad_audit_not_ordinary_edit", + "identity": "RepoAuditRepairSkillTest.test_activation_is_broad_audit_not_ordinary_edit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_audit_does_not_grant_repair_authority/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoAuditRepairSkillTest.test_audit_does_not_grant_repair_authority", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::method:RepoAuditRepairSkillTest.test_audit_does_not_grant_repair_authority", + "decorators": [], + "kind": "method", + "name": "test_audit_does_not_grant_repair_authority", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "qualified_name": "RepoAuditRepairSkillTest.test_audit_does_not_grant_repair_authority", + "signature": "def test_audit_does_not_grant_repair_authority(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 28, + "span": { + "end": { + "byte": 1072, + "column": 57, + "line": 28 + }, + "start": { + "byte": 804, + "column": 4, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_audit_does_not_grant_repair_authority", + "identity": "RepoAuditRepairSkillTest.test_audit_does_not_grant_repair_authority", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_checks_are_claim_driven_not_universal_ritual/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoAuditRepairSkillTest.test_checks_are_claim_driven_not_universal_ritual", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::method:RepoAuditRepairSkillTest.test_checks_are_claim_driven_not_universal_ritual", + "decorators": [], + "kind": "method", + "name": "test_checks_are_claim_driven_not_universal_ritual", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "qualified_name": "RepoAuditRepairSkillTest.test_checks_are_claim_driven_not_universal_ritual", + "signature": "def test_checks_are_claim_driven_not_universal_ritual(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 40, + "span": { + "end": { + "byte": 1858, + "column": 89, + "line": 40 + }, + "start": { + "byte": 1543, + "column": 4, + "line": 37 + } + }, + "start_line": 37 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_checks_are_claim_driven_not_universal_ritual", + "identity": "RepoAuditRepairSkillTest.test_checks_are_claim_driven_not_universal_ritual", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_completion_distinguishes_delivery_states/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoAuditRepairSkillTest.test_completion_distinguishes_delivery_states", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::method:RepoAuditRepairSkillTest.test_completion_distinguishes_delivery_states", + "decorators": [], + "kind": "method", + "name": "test_completion_distinguishes_delivery_states", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "qualified_name": "RepoAuditRepairSkillTest.test_completion_distinguishes_delivery_states", + "signature": "def test_completion_distinguishes_delivery_states(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 55, + "span": { + "end": { + "byte": 2750, + "column": 63, + "line": 55 + }, + "start": { + "byte": 2452, + "column": 4, + "line": 52 + } + }, + "start_line": 52 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_completion_distinguishes_delivery_states", + "identity": "RepoAuditRepairSkillTest.test_completion_distinguishes_delivery_states", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_false_green_and_partial_remote_input_are_blocked/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoAuditRepairSkillTest.test_false_green_and_partial_remote_input_are_blocked", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::method:RepoAuditRepairSkillTest.test_false_green_and_partial_remote_input_are_blocked", + "decorators": [], + "kind": "method", + "name": "test_false_green_and_partial_remote_input_are_blocked", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "qualified_name": "RepoAuditRepairSkillTest.test_false_green_and_partial_remote_input_are_blocked", + "signature": "def test_false_green_and_partial_remote_input_are_blocked(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 45, + "span": { + "end": { + "byte": 2171, + "column": 89, + "line": 45 + }, + "start": { + "byte": 1864, + "column": 4, + "line": 42 + } + }, + "start_line": 42 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_false_green_and_partial_remote_input_are_blocked", + "identity": "RepoAuditRepairSkillTest.test_false_green_and_partial_remote_input_are_blocked", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_findings_preserve_causal_classification/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoAuditRepairSkillTest.test_findings_preserve_causal_classification", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::method:RepoAuditRepairSkillTest.test_findings_preserve_causal_classification", + "decorators": [], + "kind": "method", + "name": "test_findings_preserve_causal_classification", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "qualified_name": "RepoAuditRepairSkillTest.test_findings_preserve_causal_classification", + "signature": "def test_findings_preserve_causal_classification(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 35, + "span": { + "end": { + "byte": 1537, + "column": 88, + "line": 35 + }, + "start": { + "byte": 1078, + "column": 4, + "line": 30 + } + }, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_findings_preserve_causal_classification", + "identity": "RepoAuditRepairSkillTest.test_findings_preserve_causal_classification", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_merge_admission_is_exact_revision_and_fail_closed/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoAuditRepairSkillTest.test_merge_admission_is_exact_revision_and_fail_closed", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::method:RepoAuditRepairSkillTest.test_merge_admission_is_exact_revision_and_fail_closed", + "decorators": [], + "kind": "method", + "name": "test_merge_admission_is_exact_revision_and_fail_closed", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "qualified_name": "RepoAuditRepairSkillTest.test_merge_admission_is_exact_revision_and_fail_closed", + "signature": "def test_merge_admission_is_exact_revision_and_fail_closed(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 81, + "span": { + "end": { + "byte": 4770, + "column": 106, + "line": 81 + }, + "start": { + "byte": 2756, + "column": 4, + "line": 57 + } + }, + "start_line": 57 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_merge_admission_is_exact_revision_and_fail_closed", + "identity": "RepoAuditRepairSkillTest.test_merge_admission_is_exact_revision_and_fail_closed", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_origin_is_bounded_and_hmmm_survives/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoAuditRepairSkillTest.test_origin_is_bounded_and_hmmm_survives", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::method:RepoAuditRepairSkillTest.test_origin_is_bounded_and_hmmm_survives", + "decorators": [], + "kind": "method", + "name": "test_origin_is_bounded_and_hmmm_survives", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "qualified_name": "RepoAuditRepairSkillTest.test_origin_is_bounded_and_hmmm_survives", + "signature": "def test_origin_is_bounded_and_hmmm_survives(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 91, + "span": { + "end": { + "byte": 5258, + "column": 43, + "line": 91 + }, + "start": { + "byte": 4962, + "column": 4, + "line": 87 + } + }, + "start_line": 87 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_origin_is_bounded_and_hmmm_survives", + "identity": "RepoAuditRepairSkillTest.test_origin_is_bounded_and_hmmm_survives", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_repairs_stay_at_the_owning_layer/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoAuditRepairSkillTest.test_repairs_stay_at_the_owning_layer", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::method:RepoAuditRepairSkillTest.test_repairs_stay_at_the_owning_layer", + "decorators": [], + "kind": "method", + "name": "test_repairs_stay_at_the_owning_layer", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "qualified_name": "RepoAuditRepairSkillTest.test_repairs_stay_at_the_owning_layer", + "signature": "def test_repairs_stay_at_the_owning_layer(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 50, + "span": { + "end": { + "byte": 2446, + "column": 91, + "line": 50 + }, + "start": { + "byte": 2177, + "column": 4, + "line": 47 + } + }, + "start_line": 47 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_repairs_stay_at_the_owning_layer", + "identity": "RepoAuditRepairSkillTest.test_repairs_stay_at_the_owning_layer", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_repo_loto_is_composed_not_required/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoAuditRepairSkillTest.test_repo_loto_is_composed_not_required", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::method:RepoAuditRepairSkillTest.test_repo_loto_is_composed_not_required", + "decorators": [], + "kind": "method", + "name": "test_repo_loto_is_composed_not_required", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "qualified_name": "RepoAuditRepairSkillTest.test_repo_loto_is_composed_not_required", + "signature": "def test_repo_loto_is_composed_not_required(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 85, + "span": { + "end": { + "byte": 4956, + "column": 54, + "line": 85 + }, + "start": { + "byte": 4776, + "column": 4, + "line": 83 + } + }, + "start_line": 83 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest.test_repo_loto_is_composed_not_required", + "identity": "RepoAuditRepairSkillTest.test_repo_loto_is_composed_not_required", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "RepoAuditRepairSkillTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_audit_repair_skill.py::class:RepoAuditRepairSkillTest", + "decorators": [], + "kind": "class", + "name": "RepoAuditRepairSkillTest", + "parent_identity": null, + "qualified_name": "RepoAuditRepairSkillTest", + "signature": "class RepoAuditRepairSkillTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "61cc69dcc50565b7cfc03a7b17c867904a3944af7e774c1873f3f224a009b765", + "file": "tests/test_repo_audit_repair_skill.py", + "location": { + "end_line": 91, + "span": { + "end": { + "byte": 5258, + "column": 43, + "line": 91 + }, + "start": { + "byte": 280, + "column": 0, + "line": 14 + } + }, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_audit_repair_skill.py#subject/symbol/RepoAuditRepairSkillTest", + "identity": "RepoAuditRepairSkillTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::<module>", + "metadata_kind": "shebang", + "text": "!/usr/bin/env python3" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 22, + "column": 22, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: repo_loto_evidence\n module_name: test_repo_loto\n module_kind: checks\n summary: evidentiary procedures for repo_loto CONTRACTS; standalone or pytest; --audit reconciles the declared graph without execution\n owner: Way Seer Erin\n public_surface: test_* functions, main, --audit\n internal_surface: _mk_repo, _run, _loto, _parse_block, _resolve_call, _requires_met\n tests: self\n unresolved: mutation-level verification that checks actually exercise their contracts\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 12, + "span": { + "end": { + "byte": 563, + "column": 26, + "line": 12 + }, + "start": { + "byte": 23, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CHECKS ===\nid: check_open_never_dirties\n proves: loto_open_never_dirties\n call: self::test_open_never_dirties\n requires: git, python3, posix_shell\n timeout: 20\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_close_deletes_tag\n proves: loto_close_deletes_tag\n call: self::test_close_deletes_tag\n requires: git, python3, posix_shell\n timeout: 20\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_latest_test_wins\n proves: loto_latest_test_wins\n call: self::test_latest_test_wins\n requires: git, python3, posix_shell\n timeout: 20\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_scope_enforced\n proves: loto_scope_enforced\n call: self::test_scope_enforced\n requires: git, python3, posix_shell\n timeout: 20\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_scar_blocks_work\n proves: loto_scar_blocks_work\n call: self::test_scar_blocks_work\n requires: git, python3, posix_shell\n timeout: 20\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_clear_is_empty_commit\n proves: loto_clear_is_empty_commit\n call: self::test_clear_is_empty_commit\n requires: git, python3, posix_shell\n timeout: 20\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_one_commit_per_session\n proves: loto_one_commit_per_session\n call: self::test_one_commit_per_session\n requires: git, python3, posix_shell\n timeout: 20\n mutates: filesystem\n cleanup: tempdir_teardown\n=== END CHECKS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 69, + "span": { + "end": { + "byte": 2126, + "column": 20, + "line": 69 + }, + "start": { + "byte": 564, + "column": 0, + "line": 13 + } + }, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::<module>", + "metadata_kind": "comment", + "text": "locate the module under test: env override, then common layouts" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 89, + "span": { + "end": { + "byte": 2796, + "column": 65, + "line": 89 + }, + "start": { + "byte": 2731, + "column": 0, + "line": 89 + } + }, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::<module>", + "metadata_kind": "comment", + "text": "default bound; per-check CHECKS `timeout:` overrides" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 99, + "span": { + "end": { + "byte": 3236, + "column": 76, + "line": 99 + }, + "start": { + "byte": 3182, + "column": 22, + "line": 99 + } + }, + "start_line": 99 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/comment/5", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::<module>", + "metadata_kind": "comment", + "text": "consumed: set per check by main(), read by _run" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 100, + "span": { + "end": { + "byte": 3316, + "column": 79, + "line": 100 + }, + "start": { + "byte": 3267, + "column": 30, + "line": 100 + } + }, + "start_line": 100 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/comment/6", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::<module>", + "metadata_kind": "comment", + "text": "---------- fixture ----------" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 103, + "span": { + "end": { + "byte": 3350, + "column": 31, + "line": 103 + }, + "start": { + "byte": 3319, + "column": 0, + "line": 103 + } + }, + "start_line": 103 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/comment/7", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::<module>", + "metadata_kind": "comment", + "text": "---------- checks ----------" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 163, + "span": { + "end": { + "byte": 5243, + "column": 30, + "line": 163 + }, + "start": { + "byte": 5213, + "column": 0, + "line": 163 + } + }, + "start_line": 163 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/comment/8", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::<module>", + "metadata_kind": "comment", + "text": "---------- audit: reconcile the declared graph, no execution ----------" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 301, + "span": { + "end": { + "byte": 10579, + "column": 73, + "line": 301 + }, + "start": { + "byte": 10506, + "column": 0, + "line": 301 + } + }, + "start_line": 301 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::<module>", + "description": "claims to prove them. CHECKS fields enter the schema when a runner mode\nconsumes them; this module consumes requires and per-check timeout at\nruntime, and mutates/cleanup are visible danger documentation.\n\nRun: python3 test_repo_loto.py all checks, tempdir-isolated\n python3 test_repo_loto.py --audit reconcile CONTRACTS<->CHECKS, no execution\n pytest test_repo_loto.py same checks under pytest", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Evidence for repo_loto. Contracts live in the source; this file only", + "text": "\nEvidence for repo_loto. Contracts live in the source; this file only\nclaims to prove them. CHECKS fields enter the schema when a runner mode\nconsumes them; this module consumes requires and per-check timeout at\nruntime, and mutates/cleanup are visible danger documentation.\n\nRun: python3 test_repo_loto.py all checks, tempdir-isolated\n python3 test_repo_loto.py --audit reconcile CONTRACTS<->CHECKS, no execution\n pytest test_repo_loto.py same checks under pytest\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 79, + "span": { + "end": { + "byte": 2635, + "column": 3, + "line": 79 + }, + "start": { + "byte": 2127, + "column": 0, + "line": 70 + } + }, + "start_line": 70 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 81, + "start_line": 81 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 82, + "start_line": 82 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "shutil:shutil:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "shutil", + "name": "shutil" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 83, + "start_line": 83 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "signal:signal:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "signal", + "name": "signal" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 84, + "start_line": 84 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 85, + "start_line": 85 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 86, + "start_line": 86 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:6", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 87, + "start_line": 87 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/module/tests%2Ftest_repo_loto.py", + "identity": "tests/test_repo_loto.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_append/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_append", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_append", + "decorators": [], + "kind": "function", + "name": "_append", + "parent_identity": null, + "qualified_name": "_append", + "signature": "def _append(repo, name, text)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 155, + "span": { + "end": { + "byte": 5065, + "column": 28, + "line": 155 + }, + "start": { + "byte": 4955, + "column": 0, + "line": 153 + } + }, + "start_line": 153 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_append", + "identity": "_append", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_commit_all/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_commit_all", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_commit_all", + "decorators": [], + "kind": "function", + "name": "_commit_all", + "parent_identity": null, + "qualified_name": "_commit_all", + "signature": "def _commit_all(repo, msg)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 160, + "span": { + "end": { + "byte": 5210, + "column": 61, + "line": 160 + }, + "start": { + "byte": 5068, + "column": 0, + "line": 158 + } + }, + "start_line": 158 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_commit_all", + "identity": "_commit_all", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_git_out/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_git_out", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_git_out", + "decorators": [], + "kind": "function", + "name": "_git_out", + "parent_identity": null, + "qualified_name": "_git_out", + "signature": "def _git_out(repo, *args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 146, + "span": { + "end": { + "byte": 4869, + "column": 60, + "line": 146 + }, + "start": { + "byte": 4782, + "column": 0, + "line": 145 + } + }, + "start_line": 145 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_git_out", + "identity": "_git_out", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_loto/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_loto", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_loto", + "decorators": [], + "kind": "function", + "name": "_loto", + "parent_identity": null, + "qualified_name": "_loto", + "signature": "def _loto(repo, *args)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 142, + "span": { + "end": { + "byte": 4779, + "column": 56, + "line": 142 + }, + "start": { + "byte": 4699, + "column": 0, + "line": 141 + } + }, + "start_line": 141 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_loto", + "identity": "_loto", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_mk_repo.g/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_mk_repo.g", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_mk_repo.g", + "decorators": [], + "kind": "function", + "name": "g", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_mk_repo", + "qualified_name": "_mk_repo.g", + "signature": "def g(*a)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 128, + "span": { + "end": { + "byte": 4373, + "column": 44, + "line": 128 + }, + "start": { + "byte": 4318, + "column": 4, + "line": 127 + } + }, + "start_line": 127 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_mk_repo.g", + "identity": "_mk_repo.g", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_mk_repo/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_mk_repo", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_mk_repo", + "decorators": [], + "kind": "function", + "name": "_mk_repo", + "parent_identity": null, + "qualified_name": "_mk_repo", + "signature": "def _mk_repo()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 138, + "span": { + "end": { + "byte": 4696, + "column": 12, + "line": 138 + }, + "start": { + "byte": 4251, + "column": 0, + "line": 125 + } + }, + "start_line": 125 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_mk_repo", + "identity": "_mk_repo", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_parse_block/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_parse_block", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_parse_block", + "decorators": [], + "kind": "function", + "name": "_parse_block", + "parent_identity": null, + "qualified_name": "_parse_block", + "signature": "def _parse_block(path, block)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 319, + "span": { + "end": { + "byte": 11182, + "column": 14, + "line": 319 + }, + "start": { + "byte": 10581, + "column": 0, + "line": 303 + } + }, + "start_line": 303 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_parse_block", + "identity": "_parse_block", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_parse_block/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_parse_block", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "return list of {field: value} dicts, one per id, inside block fences.", + "text": "return list of {field: value} dicts, one per id, inside block fences." + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 304, + "span": { + "end": { + "byte": 10691, + "column": 79, + "line": 304 + }, + "start": { + "byte": 10616, + "column": 4, + "line": 304 + } + }, + "start_line": 304 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_parse_block", + "identity": "_parse_block", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_porcelain/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_porcelain", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_porcelain", + "decorators": [], + "kind": "function", + "name": "_porcelain", + "parent_identity": null, + "qualified_name": "_porcelain", + "signature": "def _porcelain(repo)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 150, + "span": { + "end": { + "byte": 4952, + "column": 58, + "line": 150 + }, + "start": { + "byte": 4872, + "column": 0, + "line": 149 + } + }, + "start_line": 149 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_porcelain", + "identity": "_porcelain", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_proves_targets/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_proves_targets", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_proves_targets", + "decorators": [], + "kind": "function", + "name": "_proves_targets", + "parent_identity": null, + "qualified_name": "_proves_targets", + "signature": "def _proves_targets(check)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 337, + "span": { + "end": { + "byte": 11868, + "column": 30, + "line": 337 + }, + "start": { + "byte": 11734, + "column": 0, + "line": 335 + } + }, + "start_line": 335 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_proves_targets", + "identity": "_proves_targets", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_requires_met/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_requires_met", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_requires_met", + "decorators": [], + "kind": "function", + "name": "_requires_met", + "parent_identity": null, + "qualified_name": "_requires_met", + "signature": "def _requires_met(checks)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 389, + "span": { + "end": { + "byte": 13792, + "column": 18, + "line": 389 + }, + "start": { + "byte": 13230, + "column": 0, + "line": 376 + } + }, + "start_line": 376 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_requires_met", + "identity": "_requires_met", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_requires_met/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_requires_met", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "consume the requires: field — refuse to run what the host can't host.", + "text": "consume the requires: field — refuse to run what the host can't host." + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 377, + "span": { + "end": { + "byte": 13338, + "column": 79, + "line": 377 + }, + "start": { + "byte": 13261, + "column": 4, + "line": 377 + } + }, + "start_line": 377 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_requires_met", + "identity": "_requires_met", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_resolve_call/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_resolve_call", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_resolve_call", + "decorators": [], + "kind": "function", + "name": "_resolve_call", + "parent_identity": null, + "qualified_name": "_resolve_call", + "signature": "def _resolve_call(spec)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 332, + "span": { + "end": { + "byte": 11731, + "column": 13, + "line": 332 + }, + "start": { + "byte": 11185, + "column": 0, + "line": 322 + } + }, + "start_line": 322 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_resolve_call", + "identity": "_resolve_call", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_resolve_call/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_resolve_call", + "description": "only form: self::fn — a callable in the file that declared it.\ndotted import paths are refused: python imports execute module top\nlevel, and an audit that executes is not an audit.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "resolve a call: target to a callable without executing anything.", + "text": "resolve a call: target to a callable without executing anything.\n only form: self::fn — a callable in the file that declared it.\n dotted import paths are refused: python imports execute module top\n level, and an audit that executes is not an audit." + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 326, + "span": { + "end": { + "byte": 11479, + "column": 57, + "line": 326 + }, + "start": { + "byte": 11214, + "column": 4, + "line": 323 + } + }, + "start_line": 323 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_resolve_call", + "identity": "_resolve_call", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_run/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_run", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_run", + "decorators": [], + "kind": "function", + "name": "_run", + "parent_identity": null, + "qualified_name": "_run", + "signature": "def _run(cmd, cwd, check=False)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 122, + "span": { + "end": { + "byte": 4248, + "column": 12, + "line": 122 + }, + "start": { + "byte": 3352, + "column": 0, + "line": 105 + } + }, + "start_line": 105 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_run", + "identity": "_run", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_run/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_run", + "description": "inheriting captured pipes cannot outlive the timeout.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "bounded subprocess that owns its whole process group: descendants", + "text": "bounded subprocess that owns its whole process group: descendants\n inheriting captured pipes cannot outlive the timeout." + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 107, + "span": { + "end": { + "byte": 3518, + "column": 60, + "line": 107 + }, + "start": { + "byte": 3389, + "column": 4, + "line": 106 + } + }, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_run", + "identity": "_run", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_timeout_for/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_timeout_for", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:_timeout_for", + "decorators": [], + "kind": "function", + "name": "_timeout_for", + "parent_identity": null, + "qualified_name": "_timeout_for", + "signature": "def _timeout_for(checks, fn_name)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 399, + "span": { + "end": { + "byte": 14060, + "column": 18, + "line": 399 + }, + "start": { + "byte": 13795, + "column": 0, + "line": 392 + } + }, + "start_line": 392 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/_timeout_for", + "identity": "_timeout_for", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/audit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "audit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:audit", + "decorators": [], + "kind": "function", + "name": "audit", + "parent_identity": null, + "qualified_name": "audit", + "signature": "def audit()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 373, + "span": { + "end": { + "byte": 13227, + "column": 25, + "line": 373 + }, + "start": { + "byte": 11871, + "column": 0, + "line": 340 + } + }, + "start_line": 340 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/audit", + "identity": "audit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 429, + "span": { + "end": { + "byte": 15034, + "column": 31, + "line": 429 + }, + "start": { + "byte": 14063, + "column": 0, + "line": 402 + } + }, + "start_line": 402 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_clear_is_empty_commit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "test_clear_is_empty_commit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:test_clear_is_empty_commit", + "decorators": [], + "kind": "function", + "name": "test_clear_is_empty_commit", + "parent_identity": null, + "qualified_name": "test_clear_is_empty_commit", + "signature": "def test_clear_is_empty_commit()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 276, + "span": { + "end": { + "byte": 9779, + "column": 27, + "line": 276 + }, + "start": { + "byte": 8642, + "column": 0, + "line": 255 + } + }, + "start_line": 255 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_clear_is_empty_commit", + "identity": "test_clear_is_empty_commit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_close_deletes_tag/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "test_close_deletes_tag", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:test_close_deletes_tag", + "decorators": [], + "kind": "function", + "name": "test_close_deletes_tag", + "parent_identity": null, + "qualified_name": "test_close_deletes_tag", + "signature": "def test_close_deletes_tag()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 197, + "span": { + "end": { + "byte": 6581, + "column": 27, + "line": 197 + }, + "start": { + "byte": 5840, + "column": 0, + "line": 180 + } + }, + "start_line": 180 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_close_deletes_tag", + "identity": "test_close_deletes_tag", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_latest_test_wins/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:test_latest_test_wins", + "metadata_kind": "comment", + "text": "identical command: fail then pass -> close proceeds" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 203, + "span": { + "end": { + "byte": 6705, + "column": 61, + "line": 203 + }, + "start": { + "byte": 6652, + "column": 8, + "line": 203 + } + }, + "start_line": 203 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_latest_test_wins", + "identity": "test_latest_test_wins", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_latest_test_wins/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:test_latest_test_wins", + "metadata_kind": "comment", + "text": "fails, PASS absent" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 206, + "span": { + "end": { + "byte": 6874, + "column": 64, + "line": 206 + }, + "start": { + "byte": 6854, + "column": 44, + "line": 206 + } + }, + "start_line": 206 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_latest_test_wins", + "identity": "test_latest_test_wins", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_latest_test_wins/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:test_latest_test_wins", + "metadata_kind": "comment", + "text": "passes" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 208, + "span": { + "end": { + "byte": 6966, + "column": 52, + "line": 208 + }, + "start": { + "byte": 6958, + "column": 44, + "line": 208 + } + }, + "start_line": 208 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_latest_test_wins", + "identity": "test_latest_test_wins", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_latest_test_wins/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:test_latest_test_wins", + "metadata_kind": "comment", + "text": "distinct command whose latest run failed -> blocked" + } + }, + "origin": "native", + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 213, + "span": { + "end": { + "byte": 7246, + "column": 61, + "line": 213 + }, + "start": { + "byte": 7193, + "column": 8, + "line": 213 + } + }, + "start_line": 213 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_latest_test_wins", + "identity": "test_latest_test_wins", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_latest_test_wins/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "test_latest_test_wins", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:test_latest_test_wins", + "decorators": [], + "kind": "function", + "name": "test_latest_test_wins", + "parent_identity": null, + "qualified_name": "test_latest_test_wins", + "signature": "def test_latest_test_wins()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 223, + "span": { + "end": { + "byte": 7660, + "column": 27, + "line": 223 + }, + "start": { + "byte": 6584, + "column": 0, + "line": 200 + } + }, + "start_line": 200 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_latest_test_wins", + "identity": "test_latest_test_wins", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_one_commit_per_session/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "test_one_commit_per_session", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:test_one_commit_per_session", + "decorators": [], + "kind": "function", + "name": "test_one_commit_per_session", + "parent_identity": null, + "qualified_name": "test_one_commit_per_session", + "signature": "def test_one_commit_per_session()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 292, + "span": { + "end": { + "byte": 10276, + "column": 27, + "line": 292 + }, + "start": { + "byte": 9782, + "column": 0, + "line": 279 + } + }, + "start_line": 279 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_one_commit_per_session", + "identity": "test_one_commit_per_session", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_open_never_dirties/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "test_open_never_dirties", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:test_open_never_dirties", + "decorators": [], + "kind": "function", + "name": "test_open_never_dirties", + "parent_identity": null, + "qualified_name": "test_open_never_dirties", + "signature": "def test_open_never_dirties()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 177, + "span": { + "end": { + "byte": 5837, + "column": 27, + "line": 177 + }, + "start": { + "byte": 5245, + "column": 0, + "line": 165 + } + }, + "start_line": 165 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_open_never_dirties", + "identity": "test_open_never_dirties", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_scar_blocks_work/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "test_scar_blocks_work", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:test_scar_blocks_work", + "decorators": [], + "kind": "function", + "name": "test_scar_blocks_work", + "parent_identity": null, + "qualified_name": "test_scar_blocks_work", + "signature": "def test_scar_blocks_work()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 252, + "span": { + "end": { + "byte": 8639, + "column": 27, + "line": 252 + }, + "start": { + "byte": 8120, + "column": 0, + "line": 240 + } + }, + "start_line": 240 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_scar_blocks_work", + "identity": "test_scar_blocks_work", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_scope_enforced/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "test_scope_enforced", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto.py::function:test_scope_enforced", + "decorators": [], + "kind": "function", + "name": "test_scope_enforced", + "parent_identity": null, + "qualified_name": "test_scope_enforced", + "signature": "def test_scope_enforced()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "49638d610311cb783413c1a11657aa7af3f6a9f5c46c74541d831b27cb9ac7b9", + "file": "tests/test_repo_loto.py", + "location": { + "end_line": 237, + "span": { + "end": { + "byte": 8117, + "column": 27, + "line": 237 + }, + "start": { + "byte": 7663, + "column": 0, + "line": 226 + } + }, + "start_line": 226 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto.py#subject/symbol/test_scope_enforced", + "identity": "test_scope_enforced", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "identity": "tests/test_repo_loto_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "contextlib:contextlib:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "contextlib", + "name": "contextlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "identity": "tests/test_repo_loto_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "importlib.util:importlib.util:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "importlib.util", + "name": "importlib.util" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "identity": "tests/test_repo_loto_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "io:io:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "io", + "name": "io" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "identity": "tests/test_repo_loto_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "identity": "tests/test_repo_loto_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "identity": "tests/test_repo_loto_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/module/tests%2Ftest_repo_loto_audit.py", + "identity": "tests/test_repo_loto_audit.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.run_planted_audit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoLotoAuditNegativeTest.run_planted_audit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::method:RepoLotoAuditNegativeTest.run_planted_audit", + "decorators": [], + "kind": "method", + "name": "run_planted_audit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::class:RepoLotoAuditNegativeTest", + "qualified_name": "RepoLotoAuditNegativeTest.run_planted_audit", + "signature": "def run_planted_audit(self, *, contract_ids: list[str], checks: list[dict[str, str]], check_fns: list[object]) -> tuple[int, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 90, + "span": { + "end": { + "byte": 2761, + "column": 48, + "line": 90 + }, + "start": { + "byte": 1605, + "column": 4, + "line": 59 + } + }, + "start_line": 59 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.run_planted_audit", + "identity": "RepoLotoAuditNegativeTest.run_planted_audit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_gaps_executable_check_without_declaration/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoLotoAuditNegativeTest.test_audit_gaps_executable_check_without_declaration", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::method:RepoLotoAuditNegativeTest.test_audit_gaps_executable_check_without_declaration", + "decorators": [], + "kind": "method", + "name": "test_audit_gaps_executable_check_without_declaration", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::class:RepoLotoAuditNegativeTest", + "qualified_name": "RepoLotoAuditNegativeTest.test_audit_gaps_executable_check_without_declaration", + "signature": "def test_audit_gaps_executable_check_without_declaration(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 142, + "span": { + "end": { + "byte": 5022, + "column": 93, + "line": 142 + }, + "start": { + "byte": 4587, + "column": 4, + "line": 134 + } + }, + "start_line": 134 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_gaps_executable_check_without_declaration", + "identity": "RepoLotoAuditNegativeTest.test_audit_gaps_executable_check_without_declaration", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_gaps_orphan_contract/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoLotoAuditNegativeTest.test_audit_gaps_orphan_contract", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::method:RepoLotoAuditNegativeTest.test_audit_gaps_orphan_contract", + "decorators": [], + "kind": "method", + "name": "test_audit_gaps_orphan_contract", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::class:RepoLotoAuditNegativeTest", + "qualified_name": "RepoLotoAuditNegativeTest.test_audit_gaps_orphan_contract", + "signature": "def test_audit_gaps_orphan_contract(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 100, + "span": { + "end": { + "byte": 3201, + "column": 92, + "line": 100 + }, + "start": { + "byte": 2767, + "column": 4, + "line": 92 + } + }, + "start_line": 92 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_gaps_orphan_contract", + "identity": "RepoLotoAuditNegativeTest.test_audit_gaps_orphan_contract", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_gaps_phantom_proves_target/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoLotoAuditNegativeTest.test_audit_gaps_phantom_proves_target", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::method:RepoLotoAuditNegativeTest.test_audit_gaps_phantom_proves_target", + "decorators": [], + "kind": "method", + "name": "test_audit_gaps_phantom_proves_target", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::class:RepoLotoAuditNegativeTest", + "qualified_name": "RepoLotoAuditNegativeTest.test_audit_gaps_phantom_proves_target", + "signature": "def test_audit_gaps_phantom_proves_target(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 110, + "span": { + "end": { + "byte": 3623, + "column": 90, + "line": 110 + }, + "start": { + "byte": 3207, + "column": 4, + "line": 102 + } + }, + "start_line": 102 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_gaps_phantom_proves_target", + "identity": "RepoLotoAuditNegativeTest.test_audit_gaps_phantom_proves_target", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_gaps_unresolvable_call/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoLotoAuditNegativeTest.test_audit_gaps_unresolvable_call", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::method:RepoLotoAuditNegativeTest.test_audit_gaps_unresolvable_call", + "decorators": [], + "kind": "method", + "name": "test_audit_gaps_unresolvable_call", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::class:RepoLotoAuditNegativeTest", + "qualified_name": "RepoLotoAuditNegativeTest.test_audit_gaps_unresolvable_call", + "signature": "def test_audit_gaps_unresolvable_call(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 132, + "span": { + "end": { + "byte": 4581, + "column": 97, + "line": 132 + }, + "start": { + "byte": 4168, + "column": 4, + "line": 124 + } + }, + "start_line": 124 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_gaps_unresolvable_call", + "identity": "RepoLotoAuditNegativeTest.test_audit_gaps_unresolvable_call", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_refuses_dotted_import_resolution/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoLotoAuditNegativeTest.test_audit_refuses_dotted_import_resolution", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::method:RepoLotoAuditNegativeTest.test_audit_refuses_dotted_import_resolution", + "decorators": [], + "kind": "method", + "name": "test_audit_refuses_dotted_import_resolution", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::class:RepoLotoAuditNegativeTest", + "qualified_name": "RepoLotoAuditNegativeTest.test_audit_refuses_dotted_import_resolution", + "signature": "def test_audit_refuses_dotted_import_resolution(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 152, + "span": { + "end": { + "byte": 5434, + "column": 82, + "line": 152 + }, + "start": { + "byte": 5028, + "column": 4, + "line": 144 + } + }, + "start_line": 144 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_refuses_dotted_import_resolution", + "identity": "RepoLotoAuditNegativeTest.test_audit_refuses_dotted_import_resolution", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_splits_multi_target_proves/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoLotoAuditNegativeTest.test_audit_splits_multi_target_proves", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::method:RepoLotoAuditNegativeTest.test_audit_splits_multi_target_proves", + "decorators": [], + "kind": "method", + "name": "test_audit_splits_multi_target_proves", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::class:RepoLotoAuditNegativeTest", + "qualified_name": "RepoLotoAuditNegativeTest.test_audit_splits_multi_target_proves", + "signature": "def test_audit_splits_multi_target_proves(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 122, + "span": { + "end": { + "byte": 4162, + "column": 42, + "line": 122 + }, + "start": { + "byte": 3629, + "column": 4, + "line": 112 + } + }, + "start_line": 112 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest.test_audit_splits_multi_target_proves", + "identity": "RepoLotoAuditNegativeTest.test_audit_splits_multi_target_proves", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "RepoLotoAuditNegativeTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::class:RepoLotoAuditNegativeTest", + "decorators": [], + "kind": "class", + "name": "RepoLotoAuditNegativeTest", + "parent_identity": null, + "qualified_name": "RepoLotoAuditNegativeTest", + "signature": "class RepoLotoAuditNegativeTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 152, + "span": { + "end": { + "byte": 5434, + "column": 82, + "line": 152 + }, + "start": { + "byte": 1549, + "column": 0, + "line": 58 + } + }, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/RepoLotoAuditNegativeTest", + "identity": "RepoLotoAuditNegativeTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/_load_repo_loto_test_module/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_load_repo_loto_test_module", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::function:_load_repo_loto_test_module", + "decorators": [], + "kind": "function", + "name": "_load_repo_loto_test_module", + "parent_identity": null, + "qualified_name": "_load_repo_loto_test_module", + "signature": "def _load_repo_loto_test_module()" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 28, + "span": { + "end": { + "byte": 646, + "column": 17, + "line": 28 + }, + "start": { + "byte": 310, + "column": 0, + "line": 22 + } + }, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/_load_repo_loto_test_module", + "identity": "_load_repo_loto_test_module", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/_write_checks/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_write_checks", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::function:_write_checks", + "decorators": [], + "kind": "function", + "name": "_write_checks", + "parent_identity": null, + "qualified_name": "_write_checks", + "signature": "def _write_checks(path: Path, checks: list[dict[str, str]]) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 55, + "span": { + "end": { + "byte": 1546, + "column": 62, + "line": 55 + }, + "start": { + "byte": 1103, + "column": 0, + "line": 45 + } + }, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/_write_checks", + "identity": "_write_checks", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/_write_contracts/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_write_contracts", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::function:_write_contracts", + "decorators": [], + "kind": "function", + "name": "_write_contracts", + "parent_identity": null, + "qualified_name": "_write_contracts", + "signature": "def _write_contracts(path: Path, contract_ids: list[str]) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 42, + "span": { + "end": { + "byte": 1100, + "column": 62, + "line": 42 + }, + "start": { + "byte": 649, + "column": 0, + "line": 31 + } + }, + "start_line": 31 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/_write_contracts", + "identity": "_write_contracts", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/extra/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "extra", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::function:extra", + "decorators": [], + "kind": "function", + "name": "extra", + "parent_identity": null, + "qualified_name": "extra", + "signature": "def extra() -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 19, + "span": { + "end": { + "byte": 307, + "column": 8, + "line": 19 + }, + "start": { + "byte": 278, + "column": 0, + "line": 18 + } + }, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/extra", + "identity": "extra", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/sentinel/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "sentinel", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_repo_loto_audit.py::function:sentinel", + "decorators": [], + "kind": "function", + "name": "sentinel", + "parent_identity": null, + "qualified_name": "sentinel", + "signature": "def sentinel() -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f811b66142e7c4ff16866afe339eb271f3f7e792b18c841553b2d8a5e9ba50e6", + "file": "tests/test_repo_loto_audit.py", + "location": { + "end_line": 15, + "span": { + "end": { + "byte": 275, + "column": 8, + "line": 15 + }, + "start": { + "byte": 243, + "column": 0, + "line": 14 + } + }, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_repo_loto_audit.py#subject/symbol/sentinel", + "identity": "sentinel", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "URI recognition regressions: python -m unittest tests.test_schema_uri_detection.", + "text": "URI recognition regressions: python -m unittest tests.test_schema_uri_detection." + } + }, + "origin": "native", + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 86, + "column": 86, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "identity": "tests/test_schema_uri_detection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "identity": "tests/test_schema_uri_detection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "identity": "tests/test_schema_uri_detection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "identity": "tests/test_schema_uri_detection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "identity": "tests/test_schema_uri_detection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collect:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collect" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "identity": "tests/test_schema_uri_detection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:collection_errors:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "collection_errors" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "identity": "tests/test_schema_uri_detection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.formats:is_json_schema_uri:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.formats", + "name": "is_json_schema_uri" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/module/tests%2Ftest_schema_uri_detection.py", + "identity": "tests/test_schema_uri_detection.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.collection/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SchemaUriDetectionTests.collection", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::method:SchemaUriDetectionTests.collection", + "decorators": [], + "kind": "method", + "name": "collection", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::class:SchemaUriDetectionTests", + "qualified_name": "SchemaUriDetectionTests.collection", + "signature": "def collection(self, schema, **options)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 16, + "span": { + "end": { + "byte": 614, + "column": 78, + "line": 16 + }, + "start": { + "byte": 311, + "column": 4, + "line": 12 + } + }, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.collection", + "identity": "SchemaUriDetectionTests.collection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.test_collection_preserves_lookalikes_without_schema_classification/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SchemaUriDetectionTests.test_collection_preserves_lookalikes_without_schema_classification", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::method:SchemaUriDetectionTests.test_collection_preserves_lookalikes_without_schema_classification", + "decorators": [], + "kind": "method", + "name": "test_collection_preserves_lookalikes_without_schema_classification", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::class:SchemaUriDetectionTests", + "qualified_name": "SchemaUriDetectionTests.test_collection_preserves_lookalikes_without_schema_classification", + "signature": "def test_collection_preserves_lookalikes_without_schema_classification(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 49, + "span": { + "end": { + "byte": 2648, + "column": 90, + "line": 49 + }, + "start": { + "byte": 1921, + "column": 4, + "line": 40 + } + }, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.test_collection_preserves_lookalikes_without_schema_classification", + "identity": "SchemaUriDetectionTests.test_collection_preserves_lookalikes_without_schema_classification", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.test_exact_authority_and_canonical_drafts/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SchemaUriDetectionTests.test_exact_authority_and_canonical_drafts", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::method:SchemaUriDetectionTests.test_exact_authority_and_canonical_drafts", + "decorators": [], + "kind": "method", + "name": "test_exact_authority_and_canonical_drafts", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::class:SchemaUriDetectionTests", + "qualified_name": "SchemaUriDetectionTests.test_exact_authority_and_canonical_drafts", + "signature": "def test_exact_authority_and_canonical_drafts(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 23, + "span": { + "end": { + "byte": 969, + "column": 56, + "line": 23 + }, + "start": { + "byte": 620, + "column": 4, + "line": 18 + } + }, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.test_exact_authority_and_canonical_drafts", + "identity": "SchemaUriDetectionTests.test_exact_authority_and_canonical_drafts", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.test_host_lookalikes_userinfo_controls_and_nonstrings_rejected/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SchemaUriDetectionTests.test_host_lookalikes_userinfo_controls_and_nonstrings_rejected", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::method:SchemaUriDetectionTests.test_host_lookalikes_userinfo_controls_and_nonstrings_rejected", + "decorators": [], + "kind": "method", + "name": "test_host_lookalikes_userinfo_controls_and_nonstrings_rejected", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::class:SchemaUriDetectionTests", + "qualified_name": "SchemaUriDetectionTests.test_host_lookalikes_userinfo_controls_and_nonstrings_rejected", + "signature": "def test_host_lookalikes_userinfo_controls_and_nonstrings_rejected(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 38, + "span": { + "end": { + "byte": 1915, + "column": 57, + "line": 38 + }, + "start": { + "byte": 975, + "column": 4, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.test_host_lookalikes_userinfo_controls_and_nonstrings_rejected", + "identity": "SchemaUriDetectionTests.test_host_lookalikes_userinfo_controls_and_nonstrings_rejected", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.test_supported_draft_and_unknown_fields_still_collected/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SchemaUriDetectionTests.test_supported_draft_and_unknown_fields_still_collected", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::method:SchemaUriDetectionTests.test_supported_draft_and_unknown_fields_still_collected", + "decorators": [], + "kind": "method", + "name": "test_supported_draft_and_unknown_fields_still_collected", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::class:SchemaUriDetectionTests", + "qualified_name": "SchemaUriDetectionTests.test_supported_draft_and_unknown_fields_still_collected", + "signature": "def test_supported_draft_and_unknown_fields_still_collected(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 56, + "span": { + "end": { + "byte": 3058, + "column": 78, + "line": 56 + }, + "start": { + "byte": 2654, + "column": 4, + "line": 51 + } + }, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.test_supported_draft_and_unknown_fields_still_collected", + "identity": "SchemaUriDetectionTests.test_supported_draft_and_unknown_fields_still_collected", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.test_unknown_canonical_draft_is_unresolved_required_scope/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SchemaUriDetectionTests.test_unknown_canonical_draft_is_unresolved_required_scope", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::method:SchemaUriDetectionTests.test_unknown_canonical_draft_is_unresolved_required_scope", + "decorators": [], + "kind": "method", + "name": "test_unknown_canonical_draft_is_unresolved_required_scope", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::class:SchemaUriDetectionTests", + "qualified_name": "SchemaUriDetectionTests.test_unknown_canonical_draft_is_unresolved_required_scope", + "signature": "def test_unknown_canonical_draft_is_unresolved_required_scope(self)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 61, + "span": { + "end": { + "byte": 3396, + "column": 98, + "line": 61 + }, + "start": { + "byte": 3064, + "column": 4, + "line": 58 + } + }, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests.test_unknown_canonical_draft_is_unresolved_required_scope", + "identity": "SchemaUriDetectionTests.test_unknown_canonical_draft_is_unresolved_required_scope", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "SchemaUriDetectionTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_schema_uri_detection.py::class:SchemaUriDetectionTests", + "decorators": [], + "kind": "class", + "name": "SchemaUriDetectionTests", + "parent_identity": null, + "qualified_name": "SchemaUriDetectionTests", + "signature": "class SchemaUriDetectionTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "331448936272bd7e198c814e2e4defb489bd056c787a19fcbf7e035d4c2dff25", + "file": "tests/test_schema_uri_detection.py", + "location": { + "end_line": 61, + "span": { + "end": { + "byte": 3396, + "column": 98, + "line": 61 + }, + "start": { + "byte": 257, + "column": 0, + "line": 11 + } + }, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_schema_uri_detection.py#subject/symbol/SchemaUriDetectionTests", + "identity": "SchemaUriDetectionTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/module/tests%2Ftest_skill_compliance.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "dacc6f013dbad80bb0f7ddc868bb4b5deb0f26e77e991f94614fab027acad76c", + "file": "tests/test_skill_compliance.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/module/tests%2Ftest_skill_compliance.py", + "identity": "tests/test_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/module/tests%2Ftest_skill_compliance.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "dacc6f013dbad80bb0f7ddc868bb4b5deb0f26e77e991f94614fab027acad76c", + "file": "tests/test_skill_compliance.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/module/tests%2Ftest_skill_compliance.py", + "identity": "tests/test_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/module/tests%2Ftest_skill_compliance.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.check_skill_compliance:collect_findings:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.check_skill_compliance", + "name": "collect_findings" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "dacc6f013dbad80bb0f7ddc868bb4b5deb0f26e77e991f94614fab027acad76c", + "file": "tests/test_skill_compliance.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/module/tests%2Ftest_skill_compliance.py", + "identity": "tests/test_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/symbol/SkillComplianceCheckerTest.test_no_skill_compliance_findings/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillComplianceCheckerTest.test_no_skill_compliance_findings", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_compliance.py::method:SkillComplianceCheckerTest.test_no_skill_compliance_findings", + "decorators": [], + "kind": "method", + "name": "test_no_skill_compliance_findings", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_compliance.py::class:SkillComplianceCheckerTest", + "qualified_name": "SkillComplianceCheckerTest.test_no_skill_compliance_findings", + "signature": "def test_no_skill_compliance_findings(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "dacc6f013dbad80bb0f7ddc868bb4b5deb0f26e77e991f94614fab027acad76c", + "file": "tests/test_skill_compliance.py", + "location": { + "end_line": 10, + "span": { + "end": { + "byte": 271, + "column": 48, + "line": 10 + }, + "start": { + "byte": 170, + "column": 4, + "line": 9 + } + }, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/symbol/SkillComplianceCheckerTest.test_no_skill_compliance_findings", + "identity": "SkillComplianceCheckerTest.test_no_skill_compliance_findings", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/symbol/SkillComplianceCheckerTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "SkillComplianceCheckerTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_compliance.py::class:SkillComplianceCheckerTest", + "decorators": [], + "kind": "class", + "name": "SkillComplianceCheckerTest", + "parent_identity": null, + "qualified_name": "SkillComplianceCheckerTest", + "signature": "class SkillComplianceCheckerTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "dacc6f013dbad80bb0f7ddc868bb4b5deb0f26e77e991f94614fab027acad76c", + "file": "tests/test_skill_compliance.py", + "location": { + "end_line": 10, + "span": { + "end": { + "byte": 271, + "column": 48, + "line": 10 + }, + "start": { + "byte": 113, + "column": 0, + "line": 8 + } + }, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_compliance.py#subject/symbol/SkillComplianceCheckerTest", + "identity": "SkillComplianceCheckerTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py", + "identity": "tests/test_skill_index_semantics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py", + "identity": "tests/test_skill_index_semantics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py", + "identity": "tests/test_skill_index_semantics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py", + "identity": "tests/test_skill_index_semantics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "frontmatter:frontmatter_for:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "frontmatter", + "name": "frontmatter_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/module/tests%2Ftest_skill_index_semantics.py", + "identity": "tests/test_skill_index_semantics.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillIndexSemanticsTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::method:SkillIndexSemanticsTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::class:SkillIndexSemanticsTest", + "qualified_name": "SkillIndexSemanticsTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 18, + "span": { + "end": { + "byte": 516, + "column": 61, + "line": 18 + }, + "start": { + "byte": 314, + "column": 4, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.setUp", + "identity": "SkillIndexSemanticsTest.setUp", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_foundational_and_procedural_skill_positions_are_stable/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillIndexSemanticsTest.test_foundational_and_procedural_skill_positions_are_stable", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::method:SkillIndexSemanticsTest.test_foundational_and_procedural_skill_positions_are_stable", + "decorators": [], + "kind": "method", + "name": "test_foundational_and_procedural_skill_positions_are_stable", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::class:SkillIndexSemanticsTest", + "qualified_name": "SkillIndexSemanticsTest.test_foundational_and_procedural_skill_positions_are_stable", + "signature": "def test_foundational_and_procedural_skill_positions_are_stable(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 75, + "span": { + "end": { + "byte": 3633, + "column": 81, + "line": 75 + }, + "start": { + "byte": 3224, + "column": 4, + "line": 69 + } + }, + "start_line": 69 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_foundational_and_procedural_skill_positions_are_stable", + "identity": "SkillIndexSemanticsTest.test_foundational_and_procedural_skill_positions_are_stable", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_index_and_frontmatter_descriptions_are_present/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillIndexSemanticsTest.test_index_and_frontmatter_descriptions_are_present", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::method:SkillIndexSemanticsTest.test_index_and_frontmatter_descriptions_are_present", + "decorators": [], + "kind": "method", + "name": "test_index_and_frontmatter_descriptions_are_present", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::class:SkillIndexSemanticsTest", + "qualified_name": "SkillIndexSemanticsTest.test_index_and_frontmatter_descriptions_are_present", + "signature": "def test_index_and_frontmatter_descriptions_are_present(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 38, + "span": { + "end": { + "byte": 1598, + "column": 94, + "line": 38 + }, + "start": { + "byte": 1094, + "column": 4, + "line": 32 + } + }, + "start_line": 32 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_index_and_frontmatter_descriptions_are_present", + "identity": "SkillIndexSemanticsTest.test_index_and_frontmatter_descriptions_are_present", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_index_descriptions_match_canonical_frontmatter/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillIndexSemanticsTest.test_index_descriptions_match_canonical_frontmatter", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::method:SkillIndexSemanticsTest.test_index_descriptions_match_canonical_frontmatter", + "decorators": [], + "kind": "method", + "name": "test_index_descriptions_match_canonical_frontmatter", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::class:SkillIndexSemanticsTest", + "qualified_name": "SkillIndexSemanticsTest.test_index_descriptions_match_canonical_frontmatter", + "signature": "def test_index_descriptions_match_canonical_frontmatter(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 43, + "span": { + "end": { + "byte": 1866, + "column": 93, + "line": 43 + }, + "start": { + "byte": 1604, + "column": 4, + "line": 40 + } + }, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_index_descriptions_match_canonical_frontmatter", + "identity": "SkillIndexSemanticsTest.test_index_descriptions_match_canonical_frontmatter", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_index_names_match_frontmatter_names/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillIndexSemanticsTest.test_index_names_match_frontmatter_names", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::method:SkillIndexSemanticsTest.test_index_names_match_frontmatter_names", + "decorators": [], + "kind": "method", + "name": "test_index_names_match_frontmatter_names", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::class:SkillIndexSemanticsTest", + "qualified_name": "SkillIndexSemanticsTest.test_index_names_match_frontmatter_names", + "signature": "def test_index_names_match_frontmatter_names(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 30, + "span": { + "end": { + "byte": 1088, + "column": 79, + "line": 30 + }, + "start": { + "byte": 851, + "column": 4, + "line": 27 + } + }, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_index_names_match_frontmatter_names", + "identity": "SkillIndexSemanticsTest.test_index_names_match_frontmatter_names", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_kind_is_known_and_dependencies_match_kind/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillIndexSemanticsTest.test_kind_is_known_and_dependencies_match_kind", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::method:SkillIndexSemanticsTest.test_kind_is_known_and_dependencies_match_kind", + "decorators": [], + "kind": "method", + "name": "test_kind_is_known_and_dependencies_match_kind", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::class:SkillIndexSemanticsTest", + "qualified_name": "SkillIndexSemanticsTest.test_kind_is_known_and_dependencies_match_kind", + "signature": "def test_kind_is_known_and_dependencies_match_kind(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 67, + "span": { + "end": { + "byte": 3218, + "column": 68, + "line": 67 + }, + "start": { + "byte": 2492, + "column": 4, + "line": 55 + } + }, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_kind_is_known_and_dependencies_match_kind", + "identity": "SkillIndexSemanticsTest.test_kind_is_known_and_dependencies_match_kind", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_repo_metadata_is_canonical/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillIndexSemanticsTest.test_repo_metadata_is_canonical", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::method:SkillIndexSemanticsTest.test_repo_metadata_is_canonical", + "decorators": [], + "kind": "method", + "name": "test_repo_metadata_is_canonical", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::class:SkillIndexSemanticsTest", + "qualified_name": "SkillIndexSemanticsTest.test_repo_metadata_is_canonical", + "signature": "def test_repo_metadata_is_canonical(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 80, + "span": { + "end": { + "byte": 3903, + "column": 84, + "line": 80 + }, + "start": { + "byte": 3639, + "column": 4, + "line": 77 + } + }, + "start_line": 77 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_repo_metadata_is_canonical", + "identity": "SkillIndexSemanticsTest.test_repo_metadata_is_canonical", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_skill_names_are_unique_and_match_directory_names/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillIndexSemanticsTest.test_skill_names_are_unique_and_match_directory_names", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::method:SkillIndexSemanticsTest.test_skill_names_are_unique_and_match_directory_names", + "decorators": [], + "kind": "method", + "name": "test_skill_names_are_unique_and_match_directory_names", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::class:SkillIndexSemanticsTest", + "qualified_name": "SkillIndexSemanticsTest.test_skill_names_are_unique_and_match_directory_names", + "signature": "def test_skill_names_are_unique_and_match_directory_names(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 25, + "span": { + "end": { + "byte": 845, + "column": 61, + "line": 25 + }, + "start": { + "byte": 522, + "column": 4, + "line": 20 + } + }, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_skill_names_are_unique_and_match_directory_names", + "identity": "SkillIndexSemanticsTest.test_skill_names_are_unique_and_match_directory_names", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_superseded_skills_are_disjoint_and_have_live_replacements/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillIndexSemanticsTest.test_superseded_skills_are_disjoint_and_have_live_replacements", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::method:SkillIndexSemanticsTest.test_superseded_skills_are_disjoint_and_have_live_replacements", + "decorators": [], + "kind": "method", + "name": "test_superseded_skills_are_disjoint_and_have_live_replacements", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::class:SkillIndexSemanticsTest", + "qualified_name": "SkillIndexSemanticsTest.test_superseded_skills_are_disjoint_and_have_live_replacements", + "signature": "def test_superseded_skills_are_disjoint_and_have_live_replacements(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 53, + "span": { + "end": { + "byte": 2486, + "column": 91, + "line": 53 + }, + "start": { + "byte": 1872, + "column": 4, + "line": 45 + } + }, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest.test_superseded_skills_are_disjoint_and_have_live_replacements", + "identity": "SkillIndexSemanticsTest.test_superseded_skills_are_disjoint_and_have_live_replacements", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "SkillIndexSemanticsTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_index_semantics.py::class:SkillIndexSemanticsTest", + "decorators": [], + "kind": "class", + "name": "SkillIndexSemanticsTest", + "parent_identity": null, + "qualified_name": "SkillIndexSemanticsTest", + "signature": "class SkillIndexSemanticsTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "389f28240305eddf2044c3cbc262cc965ab26cb107b963fa6e49d68936d37811", + "file": "tests/test_skill_index_semantics.py", + "location": { + "end_line": 80, + "span": { + "end": { + "byte": 3903, + "column": 84, + "line": 80 + }, + "start": { + "byte": 260, + "column": 0, + "line": 14 + } + }, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_index_semantics.py#subject/symbol/SkillIndexSemanticsTest", + "identity": "SkillIndexSemanticsTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "identity": "tests/test_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "identity": "tests/test_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "identity": "tests/test_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:TemporaryDirectory:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tempfile", + "name": "TemporaryDirectory" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "identity": "tests/test_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.build_codex_plugin_skills:canonical_frontmatter:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.build_codex_plugin_skills", + "name": "canonical_frontmatter" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "identity": "tests/test_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.check_skill_lib_drift:check:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.check_skill_lib_drift", + "name": "check" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 14, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "identity": "tests/test_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.check_skill_lib_drift:duplicate_entry_findings:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.check_skill_lib_drift", + "name": "duplicate_entry_findings" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 14, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "identity": "tests/test_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.check_skill_lib_drift:duplicate_names:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.check_skill_lib_drift", + "name": "duplicate_names" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 14, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "identity": "tests/test_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.check_skill_lib_drift:names_in_org_list:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.check_skill_lib_drift", + "name": "names_in_org_list" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 14, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "identity": "tests/test_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.check_skill_lib_drift:names_in_readme_list:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.check_skill_lib_drift", + "name": "names_in_readme_list" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 14, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/module/tests%2Ftest_skill_lib_drift.py", + "identity": "tests/test_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest.test_canonical_frontmatter_supports_folded_trigger_descriptions/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillLibDriftCheckerTest.test_canonical_frontmatter_supports_folded_trigger_descriptions", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_lib_drift.py::method:SkillLibDriftCheckerTest.test_canonical_frontmatter_supports_folded_trigger_descriptions", + "decorators": [], + "kind": "method", + "name": "test_canonical_frontmatter_supports_folded_trigger_descriptions", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_lib_drift.py::class:SkillLibDriftCheckerTest", + "qualified_name": "SkillLibDriftCheckerTest.test_canonical_frontmatter_supports_folded_trigger_descriptions", + "signature": "def test_canonical_frontmatter_supports_folded_trigger_descriptions(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 31, + "span": { + "end": { + "byte": 1035, + "column": 13, + "line": 31 + }, + "start": { + "byte": 510, + "column": 4, + "line": 21 + } + }, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest.test_canonical_frontmatter_supports_folded_trigger_descriptions", + "identity": "SkillLibDriftCheckerTest.test_canonical_frontmatter_supports_folded_trigger_descriptions", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest.test_canonical_tree_has_no_editorial_drift_findings/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillLibDriftCheckerTest.test_canonical_tree_has_no_editorial_drift_findings", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_lib_drift.py::method:SkillLibDriftCheckerTest.test_canonical_tree_has_no_editorial_drift_findings", + "decorators": [], + "kind": "method", + "name": "test_canonical_tree_has_no_editorial_drift_findings", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_lib_drift.py::class:SkillLibDriftCheckerTest", + "qualified_name": "SkillLibDriftCheckerTest.test_canonical_tree_has_no_editorial_drift_findings", + "signature": "def test_canonical_tree_has_no_editorial_drift_findings(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 19, + "span": { + "end": { + "byte": 504, + "column": 37, + "line": 19 + }, + "start": { + "byte": 396, + "column": 4, + "line": 18 + } + }, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest.test_canonical_tree_has_no_editorial_drift_findings", + "identity": "SkillLibDriftCheckerTest.test_canonical_tree_has_no_editorial_drift_findings", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest.test_duplicate_entry_findings_cover_index_readme_and_org/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillLibDriftCheckerTest.test_duplicate_entry_findings_cover_index_readme_and_org", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_lib_drift.py::method:SkillLibDriftCheckerTest.test_duplicate_entry_findings_cover_index_readme_and_org", + "decorators": [], + "kind": "method", + "name": "test_duplicate_entry_findings_cover_index_readme_and_org", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_lib_drift.py::class:SkillLibDriftCheckerTest", + "qualified_name": "SkillLibDriftCheckerTest.test_duplicate_entry_findings_cover_index_readme_and_org", + "signature": "def test_duplicate_entry_findings_cover_index_readme_and_org(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 47, + "span": { + "end": { + "byte": 1759, + "column": 81, + "line": 47 + }, + "start": { + "byte": 1236, + "column": 4, + "line": 36 + } + }, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest.test_duplicate_entry_findings_cover_index_readme_and_org", + "identity": "SkillLibDriftCheckerTest.test_duplicate_entry_findings_cover_index_readme_and_org", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest.test_duplicate_names_reports_each_repeated_name_once/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillLibDriftCheckerTest.test_duplicate_names_reports_each_repeated_name_once", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_lib_drift.py::method:SkillLibDriftCheckerTest.test_duplicate_names_reports_each_repeated_name_once", + "decorators": [], + "kind": "method", + "name": "test_duplicate_names_reports_each_repeated_name_once", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_lib_drift.py::class:SkillLibDriftCheckerTest", + "qualified_name": "SkillLibDriftCheckerTest.test_duplicate_names_reports_each_repeated_name_once", + "signature": "def test_duplicate_names_reports_each_repeated_name_once(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 34, + "span": { + "end": { + "byte": 1230, + "column": 117, + "line": 34 + }, + "start": { + "byte": 1041, + "column": 4, + "line": 33 + } + }, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest.test_duplicate_names_reports_each_repeated_name_once", + "identity": "SkillLibDriftCheckerTest.test_duplicate_names_reports_each_repeated_name_once", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest.test_extractors_preserve_duplicates_for_duplicate_detection/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillLibDriftCheckerTest.test_extractors_preserve_duplicates_for_duplicate_detection", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_lib_drift.py::method:SkillLibDriftCheckerTest.test_extractors_preserve_duplicates_for_duplicate_detection", + "decorators": [], + "kind": "method", + "name": "test_extractors_preserve_duplicates_for_duplicate_detection", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_lib_drift.py::class:SkillLibDriftCheckerTest", + "qualified_name": "SkillLibDriftCheckerTest.test_extractors_preserve_duplicates_for_duplicate_detection", + "signature": "def test_extractors_preserve_duplicates_for_duplicate_detection(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 60, + "span": { + "end": { + "byte": 2277, + "column": 74, + "line": 60 + }, + "start": { + "byte": 1765, + "column": 4, + "line": 49 + } + }, + "start_line": 49 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest.test_extractors_preserve_duplicates_for_duplicate_detection", + "identity": "SkillLibDriftCheckerTest.test_extractors_preserve_duplicates_for_duplicate_detection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "SkillLibDriftCheckerTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_lib_drift.py::class:SkillLibDriftCheckerTest", + "decorators": [], + "kind": "class", + "name": "SkillLibDriftCheckerTest", + "parent_identity": null, + "qualified_name": "SkillLibDriftCheckerTest", + "signature": "class SkillLibDriftCheckerTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "04f4ff4b19c60b5f82817f6495afa216364b1d1e5809ff657ec18ee630765443", + "file": "tests/test_skill_lib_drift.py", + "location": { + "end_line": 60, + "span": { + "end": { + "byte": 2277, + "column": 74, + "line": 60 + }, + "start": { + "byte": 341, + "column": 0, + "line": 17 + } + }, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_lib_drift.py#subject/symbol/SkillLibDriftCheckerTest", + "identity": "SkillLibDriftCheckerTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "file": "tests/test_skill_library.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py", + "identity": "tests/test_skill_library.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "file": "tests/test_skill_library.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py", + "identity": "tests/test_skill_library.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "file": "tests/test_skill_library.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py", + "identity": "tests/test_skill_library.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "file": "tests/test_skill_library.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py", + "identity": "tests/test_skill_library.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "file": "tests/test_skill_library.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/module/tests%2Ftest_skill_library.py", + "identity": "tests/test_skill_library.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest.test_codex_plugin_adapters_match_every_canonical_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillLibraryTest.test_codex_plugin_adapters_match_every_canonical_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_library.py::method:SkillLibraryTest.test_codex_plugin_adapters_match_every_canonical_skill", + "decorators": [], + "kind": "method", + "name": "test_codex_plugin_adapters_match_every_canonical_skill", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_library.py::class:SkillLibraryTest", + "qualified_name": "SkillLibraryTest.test_codex_plugin_adapters_match_every_canonical_skill", + "signature": "def test_codex_plugin_adapters_match_every_canonical_skill(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "file": "tests/test_skill_library.py", + "location": { + "end_line": 53, + "span": { + "end": { + "byte": 2138, + "column": 57, + "line": 53 + }, + "start": { + "byte": 1546, + "column": 4, + "line": 43 + } + }, + "start_line": 43 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest.test_codex_plugin_adapters_match_every_canonical_skill", + "identity": "SkillLibraryTest.test_codex_plugin_adapters_match_every_canonical_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest.test_parser_ratio_bookends_are_single_matching_lines/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillLibraryTest.test_parser_ratio_bookends_are_single_matching_lines", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_library.py::method:SkillLibraryTest.test_parser_ratio_bookends_are_single_matching_lines", + "decorators": [], + "kind": "method", + "name": "test_parser_ratio_bookends_are_single_matching_lines", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_library.py::class:SkillLibraryTest", + "qualified_name": "SkillLibraryTest.test_parser_ratio_bookends_are_single_matching_lines", + "signature": "def test_parser_ratio_bookends_are_single_matching_lines(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "file": "tests/test_skill_library.py", + "location": { + "end_line": 86, + "span": { + "end": { + "byte": 3670, + "column": 57, + "line": 86 + }, + "start": { + "byte": 2655, + "column": 4, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest.test_parser_ratio_bookends_are_single_matching_lines", + "identity": "SkillLibraryTest.test_parser_ratio_bookends_are_single_matching_lines", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest.test_readme_lists_every_skill_once/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillLibraryTest.test_readme_lists_every_skill_once", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_library.py::method:SkillLibraryTest.test_readme_lists_every_skill_once", + "decorators": [], + "kind": "method", + "name": "test_readme_lists_every_skill_once", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_library.py::class:SkillLibraryTest", + "qualified_name": "SkillLibraryTest.test_readme_lists_every_skill_once", + "signature": "def test_readme_lists_every_skill_once(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "file": "tests/test_skill_library.py", + "location": { + "end_line": 62, + "span": { + "end": { + "byte": 2649, + "column": 57, + "line": 62 + }, + "start": { + "byte": 2144, + "column": 4, + "line": 55 + } + }, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest.test_readme_lists_every_skill_once", + "identity": "SkillLibraryTest.test_readme_lists_every_skill_once", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest.test_skill_frontmatter_has_name_and_description/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillLibraryTest.test_skill_frontmatter_has_name_and_description", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_library.py::method:SkillLibraryTest.test_skill_frontmatter_has_name_and_description", + "decorators": [], + "kind": "method", + "name": "test_skill_frontmatter_has_name_and_description", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_library.py::class:SkillLibraryTest", + "qualified_name": "SkillLibraryTest.test_skill_frontmatter_has_name_and_description", + "signature": "def test_skill_frontmatter_has_name_and_description(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "file": "tests/test_skill_library.py", + "location": { + "end_line": 41, + "span": { + "end": { + "byte": 1540, + "column": 52, + "line": 41 + }, + "start": { + "byte": 990, + "column": 4, + "line": 30 + } + }, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest.test_skill_frontmatter_has_name_and_description", + "identity": "SkillLibraryTest.test_skill_frontmatter_has_name_and_description", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest.test_skills_json_matches_skill_directories/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillLibraryTest.test_skills_json_matches_skill_directories", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_library.py::method:SkillLibraryTest.test_skills_json_matches_skill_directories", + "decorators": [], + "kind": "method", + "name": "test_skills_json_matches_skill_directories", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_library.py::class:SkillLibraryTest", + "qualified_name": "SkillLibraryTest.test_skills_json_matches_skill_directories", + "signature": "def test_skills_json_matches_skill_directories(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "file": "tests/test_skill_library.py", + "location": { + "end_line": 28, + "span": { + "end": { + "byte": 984, + "column": 75, + "line": 28 + }, + "start": { + "byte": 436, + "column": 4, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest.test_skills_json_matches_skill_directories", + "identity": "SkillLibraryTest.test_skills_json_matches_skill_directories", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "SkillLibraryTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_library.py::class:SkillLibraryTest", + "decorators": [], + "kind": "class", + "name": "SkillLibraryTest", + "parent_identity": null, + "qualified_name": "SkillLibraryTest", + "signature": "class SkillLibraryTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "656a0c56c54cc98977563de102cba711e634d740c85fd35588d383d64c812d36", + "file": "tests/test_skill_library.py", + "location": { + "end_line": 86, + "span": { + "end": { + "byte": 3670, + "column": 57, + "line": 86 + }, + "start": { + "byte": 389, + "column": 0, + "line": 18 + } + }, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_library.py#subject/symbol/SkillLibraryTest", + "identity": "SkillLibraryTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py", + "identity": "tests/test_skill_specs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py", + "identity": "tests/test_skill_specs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py", + "identity": "tests/test_skill_specs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "frontmatter:frontmatter_for:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "frontmatter", + "name": "frontmatter_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/module/tests%2Ftest_skill_specs.py", + "identity": "tests/test_skill_specs.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.assertContainsAll/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.assertContainsAll", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.assertContainsAll", + "decorators": [], + "kind": "method", + "name": "assertContainsAll", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.assertContainsAll", + "signature": "def assertContainsAll(self, text: str, required: list[str], label: str) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 19, + "span": { + "end": { + "byte": 529, + "column": 41, + "line": 19 + }, + "start": { + "byte": 318, + "column": 4, + "line": 16 + } + }, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.assertContainsAll", + "identity": "SkillSpecCoverageTest.assertContainsAll", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_canon_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_canon_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_canon_spec", + "decorators": [], + "kind": "method", + "name": "test_canon_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_canon_spec", + "signature": "def test_canon_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 222, + "span": { + "end": { + "byte": 6413, + "column": 9, + "line": 222 + }, + "start": { + "byte": 5989, + "column": 4, + "line": 207 + } + }, + "start_line": 207 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_canon_spec", + "identity": "SkillSpecCoverageTest.test_canon_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_cap_build_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_cap_build_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_cap_build_spec", + "decorators": [], + "kind": "method", + "name": "test_cap_build_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_cap_build_spec", + "signature": "def test_cap_build_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 79, + "span": { + "end": { + "byte": 2392, + "column": 9, + "line": 79 + }, + "start": { + "byte": 1932, + "column": 4, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_cap_build_spec", + "identity": "SkillSpecCoverageTest.test_cap_build_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_deps_build_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_deps_build_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_deps_build_spec", + "decorators": [], + "kind": "method", + "name": "test_deps_build_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_deps_build_spec", + "signature": "def test_deps_build_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 96, + "span": { + "end": { + "byte": 2841, + "column": 9, + "line": 96 + }, + "start": { + "byte": 2398, + "column": 4, + "line": 81 + } + }, + "start_line": 81 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_deps_build_spec", + "identity": "SkillSpecCoverageTest.test_deps_build_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_doc_build_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_doc_build_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_doc_build_spec", + "decorators": [], + "kind": "method", + "name": "test_doc_build_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_doc_build_spec", + "signature": "def test_doc_build_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 62, + "span": { + "end": { + "byte": 1926, + "column": 9, + "line": 62 + }, + "start": { + "byte": 1491, + "column": 4, + "line": 47 + } + }, + "start_line": 47 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_doc_build_spec", + "identity": "SkillSpecCoverageTest.test_doc_build_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_frontmatter_descriptions_include_load_triggers/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_frontmatter_descriptions_include_load_triggers", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_frontmatter_descriptions_include_load_triggers", + "decorators": [], + "kind": "method", + "name": "test_frontmatter_descriptions_include_load_triggers", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_frontmatter_descriptions_include_load_triggers", + "signature": "def test_frontmatter_descriptions_include_load_triggers(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 27, + "span": { + "end": { + "byte": 934, + "column": 13, + "line": 27 + }, + "start": { + "byte": 535, + "column": 4, + "line": 21 + } + }, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_frontmatter_descriptions_include_load_triggers", + "identity": "SkillSpecCoverageTest.test_frontmatter_descriptions_include_load_triggers", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_llms_build_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_llms_build_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_llms_build_spec", + "decorators": [], + "kind": "method", + "name": "test_llms_build_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_llms_build_spec", + "signature": "def test_llms_build_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 205, + "span": { + "end": { + "byte": 5983, + "column": 9, + "line": 205 + }, + "start": { + "byte": 5495, + "column": 4, + "line": 189 + } + }, + "start_line": 189 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_llms_build_spec", + "identity": "SkillSpecCoverageTest.test_llms_build_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_meta_module_build_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_meta_module_build_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_meta_module_build_spec", + "decorators": [], + "kind": "method", + "name": "test_meta_module_build_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_meta_module_build_spec", + "signature": "def test_meta_module_build_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 150, + "span": { + "end": { + "byte": 4345, + "column": 9, + "line": 150 + }, + "start": { + "byte": 3815, + "column": 4, + "line": 134 + } + }, + "start_line": 134 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_meta_module_build_spec", + "identity": "SkillSpecCoverageTest.test_meta_module_build_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_msdmd_foundation_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_msdmd_foundation_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_msdmd_foundation_spec", + "decorators": [], + "kind": "method", + "name": "test_msdmd_foundation_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_msdmd_foundation_spec", + "signature": "def test_msdmd_foundation_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 45, + "span": { + "end": { + "byte": 1485, + "column": 9, + "line": 45 + }, + "start": { + "byte": 940, + "column": 4, + "line": 29 + } + }, + "start_line": 29 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_msdmd_foundation_spec", + "identity": "SkillSpecCoverageTest.test_msdmd_foundation_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_owner_build_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_owner_build_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_owner_build_spec", + "decorators": [], + "kind": "method", + "name": "test_owner_build_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_owner_build_spec", + "signature": "def test_owner_build_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 112, + "span": { + "end": { + "byte": 3277, + "column": 9, + "line": 112 + }, + "start": { + "byte": 2847, + "column": 4, + "line": 98 + } + }, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_owner_build_spec", + "identity": "SkillSpecCoverageTest.test_owner_build_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_ratios_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_ratios_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_ratios_spec", + "decorators": [], + "kind": "method", + "name": "test_ratios_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_ratios_spec", + "signature": "def test_ratios_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 187, + "span": { + "end": { + "byte": 5489, + "column": 9, + "line": 187 + }, + "start": { + "byte": 4869, + "column": 4, + "line": 169 + } + }, + "start_line": 169 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_ratios_spec", + "identity": "SkillSpecCoverageTest.test_ratios_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_risk_boundary_build_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_risk_boundary_build_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_risk_boundary_build_spec", + "decorators": [], + "kind": "method", + "name": "test_risk_boundary_build_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_risk_boundary_build_spec", + "signature": "def test_risk_boundary_build_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 167, + "span": { + "end": { + "byte": 4863, + "column": 9, + "line": 167 + }, + "start": { + "byte": 4351, + "column": 4, + "line": 152 + } + }, + "start_line": 152 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_risk_boundary_build_spec", + "identity": "SkillSpecCoverageTest.test_risk_boundary_build_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_skill_build_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_skill_build_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_skill_build_spec", + "decorators": [], + "kind": "method", + "name": "test_skill_build_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_skill_build_spec", + "signature": "def test_skill_build_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 254, + "span": { + "end": { + "byte": 7356, + "column": 9, + "line": 254 + }, + "start": { + "byte": 6834, + "column": 4, + "line": 239 + } + }, + "start_line": 239 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_skill_build_spec", + "identity": "SkillSpecCoverageTest.test_skill_build_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_test_build_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_test_build_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_test_build_spec", + "decorators": [], + "kind": "method", + "name": "test_test_build_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_test_build_spec", + "signature": "def test_test_build_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 132, + "span": { + "end": { + "byte": 3809, + "column": 9, + "line": 132 + }, + "start": { + "byte": 3283, + "column": 4, + "line": 114 + } + }, + "start_line": 114 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_test_build_spec", + "identity": "SkillSpecCoverageTest.test_test_build_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_visitor_intro_spec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillSpecCoverageTest.test_visitor_intro_spec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::method:SkillSpecCoverageTest.test_visitor_intro_spec", + "decorators": [], + "kind": "method", + "name": "test_visitor_intro_spec", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "qualified_name": "SkillSpecCoverageTest.test_visitor_intro_spec", + "signature": "def test_visitor_intro_spec(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 237, + "span": { + "end": { + "byte": 6828, + "column": 9, + "line": 237 + }, + "start": { + "byte": 6419, + "column": 4, + "line": 224 + } + }, + "start_line": 224 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest.test_visitor_intro_spec", + "identity": "SkillSpecCoverageTest.test_visitor_intro_spec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "SkillSpecCoverageTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::class:SkillSpecCoverageTest", + "decorators": [], + "kind": "class", + "name": "SkillSpecCoverageTest", + "parent_identity": null, + "qualified_name": "SkillSpecCoverageTest", + "signature": "class SkillSpecCoverageTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 254, + "span": { + "end": { + "byte": 7356, + "column": 9, + "line": 254 + }, + "start": { + "byte": 266, + "column": 0, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/SkillSpecCoverageTest", + "identity": "SkillSpecCoverageTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/read_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_specs.py::function:read_skill", + "decorators": [], + "kind": "function", + "name": "read_skill", + "parent_identity": null, + "qualified_name": "read_skill", + "signature": "def read_skill(name: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "16c5603e6c6020164fbba0e1fcb51b4a92061d3c07aad24dc2cf70df315d92ad", + "file": "tests/test_skill_specs.py", + "location": { + "end_line": 12, + "span": { + "end": { + "byte": 263, + "column": 65, + "line": 12 + }, + "start": { + "byte": 164, + "column": 0, + "line": 11 + } + }, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_specs.py#subject/symbol/read_skill", + "identity": "read_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "identity": "tests/test_skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "identity": "tests/test_skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.skill_usage:resolve_critical:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.skill_usage", + "name": "resolve_critical" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 15, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "identity": "tests/test_skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "identity": "tests/test_skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "identity": "tests/test_skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.skill_usage:atomic_write:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.skill_usage", + "name": "atomic_write" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 15, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "identity": "tests/test_skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.skill_usage:effective_designation:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.skill_usage", + "name": "effective_designation" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 15, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "identity": "tests/test_skill_usage.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.skill_usage:empty_state:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.skill_usage", + "name": "empty_state" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 15, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "identity": "tests/test_skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.skill_usage:load_state:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.skill_usage", + "name": "load_state" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 15, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "identity": "tests/test_skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.skill_usage:parser:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.skill_usage", + "name": "parser" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 15, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "identity": "tests/test_skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.skill_usage:record_use:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.skill_usage", + "name": "record_use" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 15, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/module/tests%2Ftest_skill_usage.py", + "identity": "tests/test_skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/symbol/SkillUsageTest.test_critical_failure_caps_and_resolution_restores_maturity/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillUsageTest.test_critical_failure_caps_and_resolution_restores_maturity", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_usage.py::method:SkillUsageTest.test_critical_failure_caps_and_resolution_restores_maturity", + "decorators": [], + "kind": "method", + "name": "test_critical_failure_caps_and_resolution_restores_maturity", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_usage.py::class:SkillUsageTest", + "qualified_name": "SkillUsageTest.test_critical_failure_caps_and_resolution_restores_maturity", + "signature": "def test_critical_failure_caps_and_resolution_restores_maturity(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 38, + "span": { + "end": { + "byte": 1223, + "column": 86, + "line": 38 + }, + "start": { + "byte": 761, + "column": 4, + "line": 30 + } + }, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/symbol/SkillUsageTest.test_critical_failure_caps_and_resolution_restores_maturity", + "identity": "SkillUsageTest.test_critical_failure_caps_and_resolution_restores_maturity", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/symbol/SkillUsageTest.test_exposure_thresholds_and_quality_caps_are_distinct/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillUsageTest.test_exposure_thresholds_and_quality_caps_are_distinct", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_usage.py::method:SkillUsageTest.test_exposure_thresholds_and_quality_caps_are_distinct", + "decorators": [], + "kind": "method", + "name": "test_exposure_thresholds_and_quality_caps_are_distinct", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_usage.py::class:SkillUsageTest", + "qualified_name": "SkillUsageTest.test_exposure_thresholds_and_quality_caps_are_distinct", + "signature": "def test_exposure_thresholds_and_quality_caps_are_distinct(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 28, + "span": { + "end": { + "byte": 755, + "column": 68, + "line": 28 + }, + "start": { + "byte": 303, + "column": 4, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/symbol/SkillUsageTest.test_exposure_thresholds_and_quality_caps_are_distinct", + "identity": "SkillUsageTest.test_exposure_thresholds_and_quality_caps_are_distinct", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/symbol/SkillUsageTest.test_state_option_works_before_or_after_subcommand/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillUsageTest.test_state_option_works_before_or_after_subcommand", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_usage.py::method:SkillUsageTest.test_state_option_works_before_or_after_subcommand", + "decorators": [], + "kind": "method", + "name": "test_state_option_works_before_or_after_subcommand", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_usage.py::class:SkillUsageTest", + "qualified_name": "SkillUsageTest.test_state_option_works_before_or_after_subcommand", + "signature": "def test_state_option_works_before_or_after_subcommand(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 53, + "span": { + "end": { + "byte": 1965, + "column": 43, + "line": 53 + }, + "start": { + "byte": 1594, + "column": 4, + "line": 48 + } + }, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/symbol/SkillUsageTest.test_state_option_works_before_or_after_subcommand", + "identity": "SkillUsageTest.test_state_option_works_before_or_after_subcommand", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/symbol/SkillUsageTest.test_state_round_trip_is_atomic_and_schema_checked/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillUsageTest.test_state_round_trip_is_atomic_and_schema_checked", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_usage.py::method:SkillUsageTest.test_state_round_trip_is_atomic_and_schema_checked", + "decorators": [], + "kind": "method", + "name": "test_state_round_trip_is_atomic_and_schema_checked", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_skill_usage.py::class:SkillUsageTest", + "qualified_name": "SkillUsageTest.test_state_round_trip_is_atomic_and_schema_checked", + "signature": "def test_state_round_trip_is_atomic_and_schema_checked(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 46, + "span": { + "end": { + "byte": 1588, + "column": 53, + "line": 46 + }, + "start": { + "byte": 1229, + "column": 4, + "line": 40 + } + }, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/symbol/SkillUsageTest.test_state_round_trip_is_atomic_and_schema_checked", + "identity": "SkillUsageTest.test_state_round_trip_is_atomic_and_schema_checked", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/symbol/SkillUsageTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "SkillUsageTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_skill_usage.py::class:SkillUsageTest", + "decorators": [], + "kind": "class", + "name": "SkillUsageTest", + "parent_identity": null, + "qualified_name": "SkillUsageTest", + "signature": "class SkillUsageTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f48220bdad8948da55f8e3e128e539858ff467366d6f1062e2b3020fab8f098a", + "file": "tests/test_skill_usage.py", + "location": { + "end_line": 53, + "span": { + "end": { + "byte": 1965, + "column": 43, + "line": 53 + }, + "start": { + "byte": 258, + "column": 0, + "line": 18 + } + }, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_skill_usage.py#subject/symbol/SkillUsageTest", + "identity": "SkillUsageTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/module/tests%2Ftest_ssh_automation_skill.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/module/tests%2Ftest_ssh_automation_skill.py", + "identity": "tests/test_ssh_automation_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/module/tests%2Ftest_ssh_automation_skill.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/module/tests%2Ftest_ssh_automation_skill.py", + "identity": "tests/test_ssh_automation_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/module/tests%2Ftest_ssh_automation_skill.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/module/tests%2Ftest_ssh_automation_skill.py", + "identity": "tests/test_ssh_automation_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.setUpClass/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SshAutomationSkillTests.setUpClass", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::method:SshAutomationSkillTests.setUpClass", + "decorators": [ + "classmethod" + ], + "kind": "method", + "name": "setUpClass", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "qualified_name": "SshAutomationSkillTests.setUpClass", + "signature": "def setUpClass(cls) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 17, + "span": { + "end": { + "byte": 626, + "column": 82, + "line": 17 + }, + "start": { + "byte": 328, + "column": 4, + "line": 12 + } + }, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.setUpClass", + "identity": "SshAutomationSkillTests.setUpClass", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_frontmatter_and_boundaries_are_explicit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SshAutomationSkillTests.test_frontmatter_and_boundaries_are_explicit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::method:SshAutomationSkillTests.test_frontmatter_and_boundaries_are_explicit", + "decorators": [], + "kind": "method", + "name": "test_frontmatter_and_boundaries_are_explicit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "qualified_name": "SshAutomationSkillTests.test_frontmatter_and_boundaries_are_explicit", + "signature": "def test_frontmatter_and_boundaries_are_explicit(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 37, + "span": { + "end": { + "byte": 1462, + "column": 46, + "line": 37 + }, + "start": { + "byte": 989, + "column": 4, + "line": 26 + } + }, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_frontmatter_and_boundaries_are_explicit", + "identity": "SshAutomationSkillTests.test_frontmatter_and_boundaries_are_explicit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_generated_adapter_matches_index_description/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SshAutomationSkillTests.test_generated_adapter_matches_index_description", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::method:SshAutomationSkillTests.test_generated_adapter_matches_index_description", + "decorators": [], + "kind": "method", + "name": "test_generated_adapter_matches_index_description", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "qualified_name": "SshAutomationSkillTests.test_generated_adapter_matches_index_description", + "signature": "def test_generated_adapter_matches_index_description(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 110, + "span": { + "end": { + "byte": 4576, + "column": 48, + "line": 110 + }, + "start": { + "byte": 3855, + "column": 4, + "line": 98 + } + }, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_generated_adapter_matches_index_description", + "identity": "SshAutomationSkillTests.test_generated_adapter_matches_index_description", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_host_and_authentication_fail_closed/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SshAutomationSkillTests.test_host_and_authentication_fail_closed", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::method:SshAutomationSkillTests.test_host_and_authentication_fail_closed", + "decorators": [], + "kind": "method", + "name": "test_host_and_authentication_fail_closed", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "qualified_name": "SshAutomationSkillTests.test_host_and_authentication_fail_closed", + "signature": "def test_host_and_authentication_fail_closed(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 56, + "span": { + "end": { + "byte": 2097, + "column": 47, + "line": 56 + }, + "start": { + "byte": 1468, + "column": 4, + "line": 39 + } + }, + "start_line": 39 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_host_and_authentication_fail_closed", + "identity": "SshAutomationSkillTests.test_host_and_authentication_fail_closed", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_one_box_paste_is_child_scoped_and_prompt_free/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SshAutomationSkillTests.test_one_box_paste_is_child_scoped_and_prompt_free", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::method:SshAutomationSkillTests.test_one_box_paste_is_child_scoped_and_prompt_free", + "decorators": [], + "kind": "method", + "name": "test_one_box_paste_is_child_scoped_and_prompt_free", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "qualified_name": "SshAutomationSkillTests.test_one_box_paste_is_child_scoped_and_prompt_free", + "signature": "def test_one_box_paste_is_child_scoped_and_prompt_free(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 71, + "span": { + "end": { + "byte": 2865, + "column": 58, + "line": 71 + }, + "start": { + "byte": 2440, + "column": 4, + "line": 65 + } + }, + "start_line": 65 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_one_box_paste_is_child_scoped_and_prompt_free", + "identity": "SshAutomationSkillTests.test_one_box_paste_is_child_scoped_and_prompt_free", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_primary_sources_are_only_primary_authorities/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SshAutomationSkillTests.test_primary_sources_are_only_primary_authorities", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::method:SshAutomationSkillTests.test_primary_sources_are_only_primary_authorities", + "decorators": [], + "kind": "method", + "name": "test_primary_sources_are_only_primary_authorities", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "qualified_name": "SshAutomationSkillTests.test_primary_sources_are_only_primary_authorities", + "signature": "def test_primary_sources_are_only_primary_authorities(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 96, + "span": { + "end": { + "byte": 3849, + "column": 46, + "line": 96 + }, + "start": { + "byte": 3273, + "column": 4, + "line": 85 + } + }, + "start_line": 85 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_primary_sources_are_only_primary_authorities", + "identity": "SshAutomationSkillTests.test_primary_sources_are_only_primary_authorities", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_registered_as_procedural_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SshAutomationSkillTests.test_registered_as_procedural_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::method:SshAutomationSkillTests.test_registered_as_procedural_skill", + "decorators": [], + "kind": "method", + "name": "test_registered_as_procedural_skill", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "qualified_name": "SshAutomationSkillTests.test_registered_as_procedural_skill", + "signature": "def test_registered_as_procedural_skill(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 24, + "span": { + "end": { + "byte": 983, + "column": 61, + "line": 24 + }, + "start": { + "byte": 632, + "column": 4, + "line": 19 + } + }, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_registered_as_procedural_skill", + "identity": "SshAutomationSkillTests.test_registered_as_procedural_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_remote_shell_and_stdin_boundaries_are_preserved/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SshAutomationSkillTests.test_remote_shell_and_stdin_boundaries_are_preserved", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::method:SshAutomationSkillTests.test_remote_shell_and_stdin_boundaries_are_preserved", + "decorators": [], + "kind": "method", + "name": "test_remote_shell_and_stdin_boundaries_are_preserved", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "qualified_name": "SshAutomationSkillTests.test_remote_shell_and_stdin_boundaries_are_preserved", + "signature": "def test_remote_shell_and_stdin_boundaries_are_preserved(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 63, + "span": { + "end": { + "byte": 2434, + "column": 44, + "line": 63 + }, + "start": { + "byte": 2103, + "column": 4, + "line": 58 + } + }, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_remote_shell_and_stdin_boundaries_are_preserved", + "identity": "SshAutomationSkillTests.test_remote_shell_and_stdin_boundaries_are_preserved", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_retry_and_mutation_contracts_are_bounded/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SshAutomationSkillTests.test_retry_and_mutation_contracts_are_bounded", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::method:SshAutomationSkillTests.test_retry_and_mutation_contracts_are_bounded", + "decorators": [], + "kind": "method", + "name": "test_retry_and_mutation_contracts_are_bounded", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "qualified_name": "SshAutomationSkillTests.test_retry_and_mutation_contracts_are_bounded", + "signature": "def test_retry_and_mutation_contracts_are_bounded(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 83, + "span": { + "end": { + "byte": 3267, + "column": 47, + "line": 83 + }, + "start": { + "byte": 2871, + "column": 4, + "line": 73 + } + }, + "start_line": 73 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_retry_and_mutation_contracts_are_bounded", + "identity": "SshAutomationSkillTests.test_retry_and_mutation_contracts_are_bounded", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_root_indexes_and_doctrine_mention_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SshAutomationSkillTests.test_root_indexes_and_doctrine_mention_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::method:SshAutomationSkillTests.test_root_indexes_and_doctrine_mention_skill", + "decorators": [], + "kind": "method", + "name": "test_root_indexes_and_doctrine_mention_skill", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "qualified_name": "SshAutomationSkillTests.test_root_indexes_and_doctrine_mention_skill", + "signature": "def test_root_indexes_and_doctrine_mention_skill(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 115, + "span": { + "end": { + "byte": 4858, + "column": 59, + "line": 115 + }, + "start": { + "byte": 4582, + "column": 4, + "line": 112 + } + }, + "start_line": 112 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_root_indexes_and_doctrine_mention_skill", + "identity": "SshAutomationSkillTests.test_root_indexes_and_doctrine_mention_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_skill_does_not_create_an_llms_metadata_block/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SshAutomationSkillTests.test_skill_does_not_create_an_llms_metadata_block", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::method:SshAutomationSkillTests.test_skill_does_not_create_an_llms_metadata_block", + "decorators": [], + "kind": "method", + "name": "test_skill_does_not_create_an_llms_metadata_block", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "qualified_name": "SshAutomationSkillTests.test_skill_does_not_create_an_llms_metadata_block", + "signature": "def test_skill_does_not_create_an_llms_metadata_block(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 118, + "span": { + "end": { + "byte": 4987, + "column": 54, + "line": 118 + }, + "start": { + "byte": 4864, + "column": 4, + "line": 117 + } + }, + "start_line": 117 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests.test_skill_does_not_create_an_llms_metadata_block", + "identity": "SshAutomationSkillTests.test_skill_does_not_create_an_llms_metadata_block", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "SshAutomationSkillTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ssh_automation_skill.py::class:SshAutomationSkillTests", + "decorators": [], + "kind": "class", + "name": "SshAutomationSkillTests", + "parent_identity": null, + "qualified_name": "SshAutomationSkillTests", + "signature": "class SshAutomationSkillTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "84de3544118b5e3cb54ff2c5d7460dbb830654b4c88debb13dbfed591f1d0280", + "file": "tests/test_ssh_automation_skill.py", + "location": { + "end_line": 118, + "span": { + "end": { + "byte": 4987, + "column": 54, + "line": 118 + }, + "start": { + "byte": 274, + "column": 0, + "line": 11 + } + }, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ssh_automation_skill.py#subject/symbol/SshAutomationSkillTests", + "identity": "SshAutomationSkillTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::<module>", + "description": "Usage guidance:\n Focused: ``python -m unittest tests.test_the_interdependency_skill``\n Full repo: ``python -m unittest discover -s tests``\n\nThe focused test protects the scoped operator-workflow contract, the exact\ncross-repository authority identities for the vm-mcp/stack topology, and the\nrule that runtime host facts such as ``a0`` cannot become unconditional\norganization authority. It also guards against reintroducing a mutating\none-shot write-back workflow into the skill.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Regression guards for the canonical ``the-interdependency`` workflow skill.", + "text": "Regression guards for the canonical ``the-interdependency`` workflow skill.\n\nUsage guidance:\n Focused: ``python -m unittest tests.test_the_interdependency_skill``\n Full repo: ``python -m unittest discover -s tests``\n\nThe focused test protects the scoped operator-workflow contract, the exact\ncross-repository authority identities for the vm-mcp/stack topology, and the\nrule that runtime host facts such as ``a0`` cannot become unconditional\norganization authority. It also guards against reintroducing a mutating\none-shot write-back workflow into the skill.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 12, + "span": { + "end": { + "byte": 570, + "column": 3, + "line": 12 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py", + "identity": "tests/test_the_interdependency_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py", + "identity": "tests/test_the_interdependency_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py", + "identity": "tests/test_the_interdependency_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py", + "identity": "tests/test_the_interdependency_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/module/tests%2Ftest_the_interdependency_skill.py", + "identity": "tests/test_the_interdependency_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "TheInterdependencySkillTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::method:TheInterdependencySkillTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::class:TheInterdependencySkillTest", + "qualified_name": "TheInterdependencySkillTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 28, + "span": { + "end": { + "byte": 943, + "column": 50, + "line": 28 + }, + "start": { + "byte": 814, + "column": 4, + "line": 26 + } + }, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.setUp", + "identity": "TheInterdependencySkillTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.test_authority_topology_carries_exact_cross_repository_identities/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "TheInterdependencySkillTest.test_authority_topology_carries_exact_cross_repository_identities", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::method:TheInterdependencySkillTest.test_authority_topology_carries_exact_cross_repository_identities", + "decorators": [], + "kind": "method", + "name": "test_authority_topology_carries_exact_cross_repository_identities", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::class:TheInterdependencySkillTest", + "qualified_name": "TheInterdependencySkillTest.test_authority_topology_carries_exact_cross_repository_identities", + "signature": "def test_authority_topology_carries_exact_cross_repository_identities(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 60, + "span": { + "end": { + "byte": 2467, + "column": 75, + "line": 60 + }, + "start": { + "byte": 1589, + "column": 4, + "line": 45 + } + }, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.test_authority_topology_carries_exact_cross_repository_identities", + "identity": "TheInterdependencySkillTest.test_authority_topology_carries_exact_cross_repository_identities", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.test_deprecation_replacement_is_conditional_on_needed_capability/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "TheInterdependencySkillTest.test_deprecation_replacement_is_conditional_on_needed_capability", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::method:TheInterdependencySkillTest.test_deprecation_replacement_is_conditional_on_needed_capability", + "decorators": [], + "kind": "method", + "name": "test_deprecation_replacement_is_conditional_on_needed_capability", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::class:TheInterdependencySkillTest", + "qualified_name": "TheInterdependencySkillTest.test_deprecation_replacement_is_conditional_on_needed_capability", + "signature": "def test_deprecation_replacement_is_conditional_on_needed_capability(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 91, + "span": { + "end": { + "byte": 3876, + "column": 9, + "line": 91 + }, + "start": { + "byte": 3451, + "column": 4, + "line": 83 + } + }, + "start_line": 83 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.test_deprecation_replacement_is_conditional_on_needed_capability", + "identity": "TheInterdependencySkillTest.test_deprecation_replacement_is_conditional_on_needed_capability", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.test_no_mutating_one_shot_write_back_workflow_is_declared/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "TheInterdependencySkillTest.test_no_mutating_one_shot_write_back_workflow_is_declared", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::method:TheInterdependencySkillTest.test_no_mutating_one_shot_write_back_workflow_is_declared", + "decorators": [], + "kind": "method", + "name": "test_no_mutating_one_shot_write_back_workflow_is_declared", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::class:TheInterdependencySkillTest", + "qualified_name": "TheInterdependencySkillTest.test_no_mutating_one_shot_write_back_workflow_is_declared", + "signature": "def test_no_mutating_one_shot_write_back_workflow_is_declared(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 81, + "span": { + "end": { + "byte": 3445, + "column": 50, + "line": 81 + }, + "start": { + "byte": 3158, + "column": 4, + "line": 75 + } + }, + "start_line": 75 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.test_no_mutating_one_shot_write_back_workflow_is_declared", + "identity": "TheInterdependencySkillTest.test_no_mutating_one_shot_write_back_workflow_is_declared", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.test_operator_contract_preserves_load_bearing_rules/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "TheInterdependencySkillTest.test_operator_contract_preserves_load_bearing_rules", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::method:TheInterdependencySkillTest.test_operator_contract_preserves_load_bearing_rules", + "decorators": [], + "kind": "method", + "name": "test_operator_contract_preserves_load_bearing_rules", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::class:TheInterdependencySkillTest", + "qualified_name": "TheInterdependencySkillTest.test_operator_contract_preserves_load_bearing_rules", + "signature": "def test_operator_contract_preserves_load_bearing_rules(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 43, + "span": { + "end": { + "byte": 1583, + "column": 44, + "line": 43 + }, + "start": { + "byte": 949, + "column": 4, + "line": 30 + } + }, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.test_operator_contract_preserves_load_bearing_rules", + "identity": "TheInterdependencySkillTest.test_operator_contract_preserves_load_bearing_rules", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.test_runtime_topology_does_not_become_org_authority/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "TheInterdependencySkillTest.test_runtime_topology_does_not_become_org_authority", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::method:TheInterdependencySkillTest.test_runtime_topology_does_not_become_org_authority", + "decorators": [], + "kind": "method", + "name": "test_runtime_topology_does_not_become_org_authority", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::class:TheInterdependencySkillTest", + "qualified_name": "TheInterdependencySkillTest.test_runtime_topology_does_not_become_org_authority", + "signature": "def test_runtime_topology_does_not_become_org_authority(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 73, + "span": { + "end": { + "byte": 3152, + "column": 9, + "line": 73 + }, + "start": { + "byte": 2473, + "column": 4, + "line": 62 + } + }, + "start_line": 62 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest.test_runtime_topology_does_not_become_org_authority", + "identity": "TheInterdependencySkillTest.test_runtime_topology_does_not_become_org_authority", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "TheInterdependencySkillTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_the_interdependency_skill.py::class:TheInterdependencySkillTest", + "decorators": [], + "kind": "class", + "name": "TheInterdependencySkillTest", + "parent_identity": null, + "qualified_name": "TheInterdependencySkillTest", + "signature": "class TheInterdependencySkillTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "698820b1a7fe641347a69592fca0acf82199f376485ee6da363a59333f23e605", + "file": "tests/test_the_interdependency_skill.py", + "location": { + "end_line": 91, + "span": { + "end": { + "byte": 3876, + "column": 9, + "line": 91 + }, + "start": { + "byte": 756, + "column": 0, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_the_interdependency_skill.py#subject/symbol/TheInterdependencySkillTest", + "identity": "TheInterdependencySkillTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py", + "identity": "tests/test_ucns_option_selection_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py", + "identity": "tests/test_ucns_option_selection_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py", + "identity": "tests/test_ucns_option_selection_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "frontmatter:frontmatter_for:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "frontmatter", + "name": "frontmatter_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/module/tests%2Ftest_ucns_option_selection_skill.py", + "identity": "tests/test_ucns_option_selection_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UcnsOptionSelectionSkillTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::method:UcnsOptionSelectionSkillTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::class:UcnsOptionSelectionSkillTest", + "qualified_name": "UcnsOptionSelectionSkillTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 18, + "span": { + "end": { + "byte": 517, + "column": 49, + "line": 18 + }, + "start": { + "byte": 389, + "column": 4, + "line": 16 + } + }, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.setUp", + "identity": "UcnsOptionSelectionSkillTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_activation_and_nontrigger_are_explicit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UcnsOptionSelectionSkillTest.test_activation_and_nontrigger_are_explicit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::method:UcnsOptionSelectionSkillTest.test_activation_and_nontrigger_are_explicit", + "decorators": [], + "kind": "method", + "name": "test_activation_and_nontrigger_are_explicit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::class:UcnsOptionSelectionSkillTest", + "qualified_name": "UcnsOptionSelectionSkillTest.test_activation_and_nontrigger_are_explicit", + "signature": "def test_activation_and_nontrigger_are_explicit(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 28, + "span": { + "end": { + "byte": 878, + "column": 46, + "line": 28 + }, + "start": { + "byte": 523, + "column": 4, + "line": 20 + } + }, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_activation_and_nontrigger_are_explicit", + "identity": "UcnsOptionSelectionSkillTest.test_activation_and_nontrigger_are_explicit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_all_terminal_standings_are_defined/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UcnsOptionSelectionSkillTest.test_all_terminal_standings_are_defined", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::method:UcnsOptionSelectionSkillTest.test_all_terminal_standings_are_defined", + "decorators": [], + "kind": "method", + "name": "test_all_terminal_standings_are_defined", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::class:UcnsOptionSelectionSkillTest", + "qualified_name": "UcnsOptionSelectionSkillTest.test_all_terminal_standings_are_defined", + "signature": "def test_all_terminal_standings_are_defined(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 55, + "span": { + "end": { + "byte": 1931, + "column": 46, + "line": 55 + }, + "start": { + "byte": 1622, + "column": 4, + "line": 46 + } + }, + "start_line": 46 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_all_terminal_standings_are_defined", + "identity": "UcnsOptionSelectionSkillTest.test_all_terminal_standings_are_defined", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_codex_adapter_points_to_canonical_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UcnsOptionSelectionSkillTest.test_codex_adapter_points_to_canonical_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::method:UcnsOptionSelectionSkillTest.test_codex_adapter_points_to_canonical_skill", + "decorators": [], + "kind": "method", + "name": "test_codex_adapter_points_to_canonical_skill", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::class:UcnsOptionSelectionSkillTest", + "qualified_name": "UcnsOptionSelectionSkillTest.test_codex_adapter_points_to_canonical_skill", + "signature": "def test_codex_adapter_points_to_canonical_skill(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 73, + "span": { + "end": { + "byte": 2973, + "column": 67, + "line": 73 + }, + "start": { + "byte": 2712, + "column": 4, + "line": 70 + } + }, + "start_line": 70 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_codex_adapter_points_to_canonical_skill", + "identity": "UcnsOptionSelectionSkillTest.test_codex_adapter_points_to_canonical_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_hard_gates_cannot_be_compensated/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UcnsOptionSelectionSkillTest.test_hard_gates_cannot_be_compensated", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::method:UcnsOptionSelectionSkillTest.test_hard_gates_cannot_be_compensated", + "decorators": [], + "kind": "method", + "name": "test_hard_gates_cannot_be_compensated", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::class:UcnsOptionSelectionSkillTest", + "qualified_name": "UcnsOptionSelectionSkillTest.test_hard_gates_cannot_be_compensated", + "signature": "def test_hard_gates_cannot_be_compensated(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 33, + "span": { + "end": { + "byte": 1184, + "column": 75, + "line": 33 + }, + "start": { + "byte": 884, + "column": 4, + "line": 30 + } + }, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_hard_gates_cannot_be_compensated", + "identity": "UcnsOptionSelectionSkillTest.test_hard_gates_cannot_be_compensated", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_ratification_and_nontransfer_are_explicit/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UcnsOptionSelectionSkillTest.test_ratification_and_nontransfer_are_explicit", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::method:UcnsOptionSelectionSkillTest.test_ratification_and_nontransfer_are_explicit", + "decorators": [], + "kind": "method", + "name": "test_ratification_and_nontransfer_are_explicit", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::class:UcnsOptionSelectionSkillTest", + "qualified_name": "UcnsOptionSelectionSkillTest.test_ratification_and_nontransfer_are_explicit", + "signature": "def test_ratification_and_nontransfer_are_explicit(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 60, + "span": { + "end": { + "byte": 2220, + "column": 59, + "line": 60 + }, + "start": { + "byte": 1937, + "column": 4, + "line": 57 + } + }, + "start_line": 57 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_ratification_and_nontransfer_are_explicit", + "identity": "UcnsOptionSelectionSkillTest.test_ratification_and_nontransfer_are_explicit", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_scope_identity_evidence_and_replay_are_required/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UcnsOptionSelectionSkillTest.test_scope_identity_evidence_and_replay_are_required", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::method:UcnsOptionSelectionSkillTest.test_scope_identity_evidence_and_replay_are_required", + "decorators": [], + "kind": "method", + "name": "test_scope_identity_evidence_and_replay_are_required", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::class:UcnsOptionSelectionSkillTest", + "qualified_name": "UcnsOptionSelectionSkillTest.test_scope_identity_evidence_and_replay_are_required", + "signature": "def test_scope_identity_evidence_and_replay_are_required(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 44, + "span": { + "end": { + "byte": 1616, + "column": 44, + "line": 44 + }, + "start": { + "byte": 1190, + "column": 4, + "line": 35 + } + }, + "start_line": 35 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_scope_identity_evidence_and_replay_are_required", + "identity": "UcnsOptionSelectionSkillTest.test_scope_identity_evidence_and_replay_are_required", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_unresolved_authorizes_candidate_work_not_promotion/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UcnsOptionSelectionSkillTest.test_unresolved_authorizes_candidate_work_not_promotion", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::method:UcnsOptionSelectionSkillTest.test_unresolved_authorizes_candidate_work_not_promotion", + "decorators": [], + "kind": "method", + "name": "test_unresolved_authorizes_candidate_work_not_promotion", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::class:UcnsOptionSelectionSkillTest", + "qualified_name": "UcnsOptionSelectionSkillTest.test_unresolved_authorizes_candidate_work_not_promotion", + "signature": "def test_unresolved_authorizes_candidate_work_not_promotion(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 68, + "span": { + "end": { + "byte": 2706, + "column": 79, + "line": 68 + }, + "start": { + "byte": 2226, + "column": 4, + "line": 62 + } + }, + "start_line": 62 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest.test_unresolved_authorizes_candidate_work_not_promotion", + "identity": "UcnsOptionSelectionSkillTest.test_unresolved_authorizes_candidate_work_not_promotion", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "UcnsOptionSelectionSkillTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_ucns_option_selection_skill.py::class:UcnsOptionSelectionSkillTest", + "decorators": [], + "kind": "class", + "name": "UcnsOptionSelectionSkillTest", + "parent_identity": null, + "qualified_name": "UcnsOptionSelectionSkillTest", + "signature": "class UcnsOptionSelectionSkillTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "77c732a53c0eb549577b1cbdb62bb493fa85fb47de7e192aea5767849cd8f0b2", + "file": "tests/test_ucns_option_selection_skill.py", + "location": { + "end_line": 73, + "span": { + "end": { + "byte": 2973, + "column": 67, + "line": 73 + }, + "start": { + "byte": 330, + "column": 0, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_ucns_option_selection_skill.py#subject/symbol/UcnsOptionSelectionSkillTest", + "identity": "UcnsOptionSelectionSkillTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CHECKS ===\nid: check_msdmd_python_numeric_field_contract\n proves: msdmd_python_parser_preserves_field_names\n call: self::test_parser_field_contract\n requires: python3\n timeout: 10\n mutates: filesystem\n cleanup: tempdir_teardown\n=== END CHECKS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 9, + "span": { + "end": { + "byte": 274, + "column": 20, + "line": 9 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CHECKS ===\nid: check_msdmd_typescript_numeric_field_contract\n proves: msdmd_typescript_parser_preserves_field_names\n call: self::test_typescript_parser_field_contract\n requires: python3, node24\n timeout: 10\n mutates: filesystem\n cleanup: tempdir_teardown\n=== END CHECKS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 61, + "span": { + "end": { + "byte": 2238, + "column": 20, + "line": 61 + }, + "start": { + "byte": 1937, + "column": 0, + "line": 53 + } + }, + "start_line": 53 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:parse_ratios:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "parse_ratios" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 27, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:parse_text:11", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "parse_text" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 27, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/12", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:ratios_placement:12", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "ratios_placement" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 27, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/13", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:walk_tree:13", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "walk_tree" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 27, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:COMMENT_MARKERS:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "COMMENT_MARKERS" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 27, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:marker_for:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "marker_for" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 27, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.parsers.universal:parse_file:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.parsers.universal", + "name": "parse_file" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 27, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/module/tests%2Ftest_universal_parser.py", + "identity": "tests/test_universal_parser.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_marker_for_known_and_unknown_extensions/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_marker_for_known_and_unknown_extensions", + "metadata_kind": "comment", + "text": ".m is ambiguous between Objective-C and MATLAB/Octave. Extension-only\ndetection must not guess; callers can use parse_text with a marker." + } + }, + "origin": "native", + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 167, + "span": { + "end": { + "byte": 6832, + "column": 77, + "line": 167 + }, + "start": { + "byte": 6683, + "column": 8, + "line": 166 + } + }, + "start_line": 166 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_marker_for_known_and_unknown_extensions", + "identity": "UniversalParserTest.test_marker_for_known_and_unknown_extensions", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_marker_for_known_and_unknown_extensions/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_marker_for_known_and_unknown_extensions", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_marker_for_known_and_unknown_extensions", + "decorators": [], + "kind": "method", + "name": "test_marker_for_known_and_unknown_extensions", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_marker_for_known_and_unknown_extensions", + "signature": "def test_marker_for_known_and_unknown_extensions(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 169, + "span": { + "end": { + "byte": 6945, + "column": 56, + "line": 169 + }, + "start": { + "byte": 5865, + "column": 4, + "line": 153 + } + }, + "start_line": 153 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_marker_for_known_and_unknown_extensions", + "identity": "UniversalParserTest.test_marker_for_known_and_unknown_extensions", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_missing_block_returns_empty_list/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_missing_block_returns_empty_list", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_missing_block_returns_empty_list", + "decorators": [], + "kind": "method", + "name": "test_missing_block_returns_empty_list", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_missing_block_returns_empty_list", + "signature": "def test_missing_block_returns_empty_list(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 151, + "span": { + "end": { + "byte": 5859, + "column": 74, + "line": 151 + }, + "start": { + "byte": 5728, + "column": 4, + "line": 150 + } + }, + "start_line": 150 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_missing_block_returns_empty_list", + "identity": "UniversalParserTest.test_missing_block_returns_empty_list", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_all_matching_blocks_not_just_first/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_all_matching_blocks_not_just_first", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_all_matching_blocks_not_just_first", + "decorators": [], + "kind": "method", + "name": "test_parse_all_matching_blocks_not_just_first", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_all_matching_blocks_not_just_first", + "signature": "def test_parse_all_matching_blocks_not_just_first(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 123, + "span": { + "end": { + "byte": 4906, + "column": 9, + "line": 123 + }, + "start": { + "byte": 4456, + "column": 4, + "line": 106 + } + }, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_all_matching_blocks_not_just_first", + "identity": "UniversalParserTest.test_parse_all_matching_blocks_not_just_first", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_file_supports_additional_language_comment_families/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_file_supports_additional_language_comment_families", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_file_supports_additional_language_comment_families", + "decorators": [], + "kind": "method", + "name": "test_parse_file_supports_additional_language_comment_families", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_file_supports_additional_language_comment_families", + "signature": "def test_parse_file_supports_additional_language_comment_families(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 221, + "span": { + "end": { + "byte": 9064, + "column": 21, + "line": 221 + }, + "start": { + "byte": 7841, + "column": 4, + "line": 193 + } + }, + "start_line": 193 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_file_supports_additional_language_comment_families", + "identity": "UniversalParserTest.test_parse_file_supports_additional_language_comment_families", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_file_uses_extension_marker/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_file_uses_extension_marker", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_file_uses_extension_marker", + "decorators": [], + "kind": "method", + "name": "test_parse_file_uses_extension_marker", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_file_uses_extension_marker", + "signature": "def test_parse_file_uses_extension_marker(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 191, + "span": { + "end": { + "byte": 7835, + "column": 13, + "line": 191 + }, + "start": { + "byte": 7352, + "column": 4, + "line": 177 + } + }, + "start_line": 177 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_file_uses_extension_marker", + "identity": "UniversalParserTest.test_parse_file_uses_extension_marker", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_numeric_snake_case_field/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_numeric_snake_case_field", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_numeric_snake_case_field", + "decorators": [], + "kind": "method", + "name": "test_parse_numeric_snake_case_field", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_numeric_snake_case_field", + "signature": "def test_parse_numeric_snake_case_field(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 126, + "span": { + "end": { + "byte": 5003, + "column": 36, + "line": 126 + }, + "start": { + "byte": 4912, + "column": 4, + "line": 125 + } + }, + "start_line": 125 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_numeric_snake_case_field", + "identity": "UniversalParserTest.test_parse_numeric_snake_case_field", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_allows_node_shebang_before_slash_marker/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_ratios_allows_node_shebang_before_slash_marker", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_ratios_allows_node_shebang_before_slash_marker", + "decorators": [], + "kind": "method", + "name": "test_parse_ratios_allows_node_shebang_before_slash_marker", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_ratios_allows_node_shebang_before_slash_marker", + "signature": "def test_parse_ratios_allows_node_shebang_before_slash_marker(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 299, + "span": { + "end": { + "byte": 12144, + "column": 68, + "line": 299 + }, + "start": { + "byte": 11729, + "column": 4, + "line": 292 + } + }, + "start_line": 292 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_allows_node_shebang_before_slash_marker", + "identity": "UniversalParserTest.test_parse_ratios_allows_node_shebang_before_slash_marker", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_allows_valid_line_one_shebang/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_ratios_allows_valid_line_one_shebang", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_ratios_allows_valid_line_one_shebang", + "decorators": [], + "kind": "method", + "name": "test_parse_ratios_allows_valid_line_one_shebang", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_ratios_allows_valid_line_one_shebang", + "signature": "def test_parse_ratios_allows_valid_line_one_shebang(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 290, + "span": { + "end": { + "byte": 11723, + "column": 67, + "line": 290 + }, + "start": { + "byte": 11326, + "column": 4, + "line": 283 + } + }, + "start_line": 283 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_allows_valid_line_one_shebang", + "identity": "UniversalParserTest.test_parse_ratios_allows_valid_line_one_shebang", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_detects_misplacement/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_ratios_detects_misplacement", + "metadata_kind": "comment", + "text": "present but on neither the first nor the last non-blank line" + } + }, + "origin": "native", + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 324, + "span": { + "end": { + "byte": 13102, + "column": 70, + "line": 324 + }, + "start": { + "byte": 13040, + "column": 8, + "line": 324 + } + }, + "start_line": 324 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_detects_misplacement", + "identity": "UniversalParserTest.test_parse_ratios_detects_misplacement", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_detects_misplacement/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_ratios_detects_misplacement", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_ratios_detects_misplacement", + "decorators": [], + "kind": "method", + "name": "test_parse_ratios_detects_misplacement", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_ratios_detects_misplacement", + "signature": "def test_parse_ratios_detects_misplacement(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 326, + "span": { + "end": { + "byte": 13230, + "column": 57, + "line": 326 + }, + "start": { + "byte": 12872, + "column": 4, + "line": 322 + } + }, + "start_line": 322 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_detects_misplacement", + "identity": "UniversalParserTest.test_parse_ratios_detects_misplacement", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_reads_single_line_declarations/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_ratios_reads_single_line_declarations", + "metadata_kind": "comment", + "text": "one entry per (line x ratio token): 2 lines x 3 ratios" + } + }, + "origin": "native", + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 278, + "span": { + "end": { + "byte": 11130, + "column": 64, + "line": 278 + }, + "start": { + "byte": 11074, + "column": 8, + "line": 278 + } + }, + "start_line": 278 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_reads_single_line_declarations", + "identity": "UniversalParserTest.test_parse_ratios_reads_single_line_declarations", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_reads_single_line_declarations/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_ratios_reads_single_line_declarations", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_ratios_reads_single_line_declarations", + "decorators": [], + "kind": "method", + "name": "test_parse_ratios_reads_single_line_declarations", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_ratios_reads_single_line_declarations", + "signature": "def test_parse_ratios_reads_single_line_declarations(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 281, + "span": { + "end": { + "byte": 11320, + "column": 67, + "line": 281 + }, + "start": { + "byte": 10700, + "column": 4, + "line": 270 + } + }, + "start_line": 270 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_reads_single_line_declarations", + "identity": "UniversalParserTest.test_parse_ratios_reads_single_line_declarations", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_rejects_invalid_or_gapped_shebang_preamble/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_ratios_rejects_invalid_or_gapped_shebang_preamble", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_ratios_rejects_invalid_or_gapped_shebang_preamble", + "decorators": [], + "kind": "method", + "name": "test_parse_ratios_rejects_invalid_or_gapped_shebang_preamble", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_ratios_rejects_invalid_or_gapped_shebang_preamble", + "signature": "def test_parse_ratios_rejects_invalid_or_gapped_shebang_preamble(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 320, + "span": { + "end": { + "byte": 12866, + "column": 9, + "line": 320 + }, + "start": { + "byte": 12150, + "column": 4, + "line": 301 + } + }, + "start_line": 301 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_ratios_rejects_invalid_or_gapped_shebang_preamble", + "identity": "UniversalParserTest.test_parse_ratios_rejects_invalid_or_gapped_shebang_preamble", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_single_block_with_multiple_entries/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_single_block_with_multiple_entries", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_single_block_with_multiple_entries", + "decorators": [], + "kind": "method", + "name": "test_parse_single_block_with_multiple_entries", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_single_block_with_multiple_entries", + "signature": "def test_parse_single_block_with_multiple_entries(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 104, + "span": { + "end": { + "byte": 4450, + "column": 9, + "line": 104 + }, + "start": { + "byte": 3886, + "column": 4, + "line": 87 + } + }, + "start_line": 87 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_single_block_with_multiple_entries", + "identity": "UniversalParserTest.test_parse_single_block_with_multiple_entries", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_sql_comment_marker/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_sql_comment_marker", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_sql_comment_marker", + "decorators": [], + "kind": "method", + "name": "test_parse_sql_comment_marker", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_sql_comment_marker", + "signature": "def test_parse_sql_comment_marker(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 148, + "span": { + "end": { + "byte": 5722, + "column": 9, + "line": 148 + }, + "start": { + "byte": 5363, + "column": 4, + "line": 139 + } + }, + "start_line": 139 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_sql_comment_marker", + "identity": "UniversalParserTest.test_parse_sql_comment_marker", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_typescript_comment_marker/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_parse_typescript_comment_marker", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_parse_typescript_comment_marker", + "decorators": [], + "kind": "method", + "name": "test_parse_typescript_comment_marker", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_parse_typescript_comment_marker", + "signature": "def test_parse_typescript_comment_marker(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 137, + "span": { + "end": { + "byte": 5357, + "column": 9, + "line": 137 + }, + "start": { + "byte": 5009, + "column": 4, + "line": 128 + } + }, + "start_line": 128 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_parse_typescript_comment_marker", + "identity": "UniversalParserTest.test_parse_typescript_comment_marker", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_python_and_typescript_comment_marker_registries_match/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_python_and_typescript_comment_marker_registries_match", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_python_and_typescript_comment_marker_registries_match", + "decorators": [], + "kind": "method", + "name": "test_python_and_typescript_comment_marker_registries_match", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_python_and_typescript_comment_marker_registries_match", + "signature": "def test_python_and_typescript_comment_marker_registries_match(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 175, + "span": { + "end": { + "byte": 7346, + "column": 61, + "line": 175 + }, + "start": { + "byte": 6951, + "column": 4, + "line": 171 + } + }, + "start_line": 171 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_python_and_typescript_comment_marker_registries_match", + "identity": "UniversalParserTest.test_python_and_typescript_comment_marker_registries_match", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_typescript_numeric_field_contract/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_typescript_numeric_field_contract", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_typescript_numeric_field_contract", + "decorators": [], + "kind": "method", + "name": "test_typescript_numeric_field_contract", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_typescript_numeric_field_contract", + "signature": "def test_typescript_numeric_field_contract(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 85, + "span": { + "end": { + "byte": 3880, + "column": 47, + "line": 85 + }, + "start": { + "byte": 3775, + "column": 4, + "line": 84 + } + }, + "start_line": 84 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_typescript_numeric_field_contract", + "identity": "UniversalParserTest.test_typescript_numeric_field_contract", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_walk_tree_reports_annotated_and_gaps/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_walk_tree_reports_annotated_and_gaps", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_walk_tree_reports_annotated_and_gaps", + "decorators": [], + "kind": "method", + "name": "test_walk_tree_reports_annotated_and_gaps", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_walk_tree_reports_annotated_and_gaps", + "signature": "def test_walk_tree_reports_annotated_and_gaps(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 246, + "span": { + "end": { + "byte": 9961, + "column": 46, + "line": 246 + }, + "start": { + "byte": 9070, + "column": 4, + "line": 223 + } + }, + "start_line": 223 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_walk_tree_reports_annotated_and_gaps", + "identity": "UniversalParserTest.test_walk_tree_reports_annotated_and_gaps", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_walk_tree_skips_vendored_agent_skills/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "UniversalParserTest.test_walk_tree_skips_vendored_agent_skills", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::method:UniversalParserTest.test_walk_tree_skips_vendored_agent_skills", + "decorators": [], + "kind": "method", + "name": "test_walk_tree_skips_vendored_agent_skills", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "qualified_name": "UniversalParserTest.test_walk_tree_skips_vendored_agent_skills", + "signature": "def test_walk_tree_skips_vendored_agent_skills(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 268, + "span": { + "end": { + "byte": 10694, + "column": 50, + "line": 268 + }, + "start": { + "byte": 9967, + "column": 4, + "line": 248 + } + }, + "start_line": 248 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest.test_walk_tree_skips_vendored_agent_skills", + "identity": "UniversalParserTest.test_walk_tree_skips_vendored_agent_skills", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "UniversalParserTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::class:UniversalParserTest", + "decorators": [], + "kind": "class", + "name": "UniversalParserTest", + "parent_identity": null, + "qualified_name": "UniversalParserTest", + "signature": "class UniversalParserTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 326, + "span": { + "end": { + "byte": 13230, + "column": 57, + "line": 326 + }, + "start": { + "byte": 3725, + "column": 0, + "line": 83 + } + }, + "start_line": 83 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/UniversalParserTest", + "identity": "UniversalParserTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/test_parser_field_contract/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "test_parser_field_contract", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::function:test_parser_field_contract", + "decorators": [], + "kind": "function", + "name": "test_parser_field_contract", + "parent_identity": null, + "qualified_name": "test_parser_field_contract", + "signature": "def test_parser_field_contract() -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 50, + "span": { + "end": { + "byte": 1934, + "column": 80, + "line": 50 + }, + "start": { + "byte": 619, + "column": 0, + "line": 32 + } + }, + "start_line": 32 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/test_parser_field_contract", + "identity": "test_parser_field_contract", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/test_parser_field_contract/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::function:test_parser_field_contract", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "No-argument CHECKS witness, also executed by the unittest suite.", + "text": "No-argument CHECKS witness, also executed by the unittest suite." + } + }, + "origin": "native", + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 33, + "span": { + "end": { + "byte": 735, + "column": 74, + "line": 33 + }, + "start": { + "byte": 665, + "column": 4, + "line": 33 + } + }, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/test_parser_field_contract", + "identity": "test_parser_field_contract", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/test_typescript_parser_field_contract/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "test_typescript_parser_field_contract", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::function:test_typescript_parser_field_contract", + "decorators": [], + "kind": "function", + "name": "test_typescript_parser_field_contract", + "parent_identity": null, + "qualified_name": "test_typescript_parser_field_contract", + "signature": "def test_typescript_parser_field_contract() -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 80, + "span": { + "end": { + "byte": 3722, + "column": 91, + "line": 80 + }, + "start": { + "byte": 2241, + "column": 0, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/test_typescript_parser_field_contract", + "identity": "test_typescript_parser_field_contract", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/test_typescript_parser_field_contract/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_universal_parser.py::function:test_typescript_parser_field_contract", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Execute the actual TypeScript parser using Node's native type stripping.", + "text": "Execute the actual TypeScript parser using Node's native type stripping." + } + }, + "origin": "native", + "source": { + "content_sha256": "6570636a782bb13c29ae432e115ca472af24ca822c9627a310a2c1518127e530", + "file": "tests/test_universal_parser.py", + "location": { + "end_line": 65, + "span": { + "end": { + "byte": 2376, + "column": 82, + "line": 65 + }, + "start": { + "byte": 2298, + "column": 4, + "line": 65 + } + }, + "start_line": 65 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_universal_parser.py#subject/symbol/test_typescript_parser_field_contract", + "identity": "test_typescript_parser_field_contract", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "identity": "tests/test_visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "identity": "tests/test_visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "identity": "tests/test_visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "identity": "tests/test_visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "identity": "tests/test_visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.collect:render_typescript:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.collect", + "name": "render_typescript" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "identity": "tests/test_visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.visualize:_node_id:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.visualize", + "name": "_node_id" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "identity": "tests/test_visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.visualize:load_collection:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.visualize", + "name": "load_collection" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "identity": "tests/test_visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "msdmd.visualize:render_mermaid:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "msdmd.visualize", + "name": "render_mermaid" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/module/tests%2Ftest_visualize.py", + "identity": "tests/test_visualize.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.sample_collection/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VisualizeTest.sample_collection", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::method:VisualizeTest.sample_collection", + "decorators": [], + "kind": "method", + "name": "sample_collection", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::class:VisualizeTest", + "qualified_name": "VisualizeTest.sample_collection", + "signature": "def sample_collection(self) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 34, + "span": { + "end": { + "byte": 992, + "column": 9, + "line": 34 + }, + "start": { + "byte": 266, + "column": 4, + "line": 13 + } + }, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.sample_collection", + "identity": "VisualizeTest.sample_collection", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_generated_schema_two_with_legacy_name_in_payload/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VisualizeTest.test_load_collection_reads_generated_schema_two_with_legacy_name_in_payload", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::method:VisualizeTest.test_load_collection_reads_generated_schema_two_with_legacy_name_in_payload", + "decorators": [], + "kind": "method", + "name": "test_load_collection_reads_generated_schema_two_with_legacy_name_in_payload", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::class:VisualizeTest", + "qualified_name": "VisualizeTest.test_load_collection_reads_generated_schema_two_with_legacy_name_in_payload", + "signature": "def test_load_collection_reads_generated_schema_two_with_legacy_name_in_payload(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 70, + "span": { + "end": { + "byte": 2534, + "column": 62, + "line": 70 + }, + "start": { + "byte": 1722, + "column": 4, + "line": 51 + } + }, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_generated_schema_two_with_legacy_name_in_payload", + "identity": "VisualizeTest.test_load_collection_reads_generated_schema_two_with_legacy_name_in_payload", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_generated_typescript/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VisualizeTest.test_load_collection_reads_generated_typescript", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::method:VisualizeTest.test_load_collection_reads_generated_typescript", + "decorators": [], + "kind": "method", + "name": "test_load_collection_reads_generated_typescript", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::class:VisualizeTest", + "qualified_name": "VisualizeTest.test_load_collection_reads_generated_typescript", + "signature": "def test_load_collection_reads_generated_typescript(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 49, + "span": { + "end": { + "byte": 1716, + "column": 69, + "line": 49 + }, + "start": { + "byte": 1308, + "column": 4, + "line": 42 + } + }, + "start_line": 42 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_generated_typescript", + "identity": "VisualizeTest.test_load_collection_reads_generated_typescript", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_hand_authored_typescript/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VisualizeTest.test_load_collection_reads_hand_authored_typescript", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::method:VisualizeTest.test_load_collection_reads_hand_authored_typescript", + "decorators": [], + "kind": "method", + "name": "test_load_collection_reads_hand_authored_typescript", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::class:VisualizeTest", + "qualified_name": "VisualizeTest.test_load_collection_reads_hand_authored_typescript", + "signature": "def test_load_collection_reads_hand_authored_typescript(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 107, + "span": { + "end": { + "byte": 4147, + "column": 62, + "line": 107 + }, + "start": { + "byte": 2540, + "column": 4, + "line": 72 + } + }, + "start_line": 72 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_hand_authored_typescript", + "identity": "VisualizeTest.test_load_collection_reads_hand_authored_typescript", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_json/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VisualizeTest.test_load_collection_reads_json", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::method:VisualizeTest.test_load_collection_reads_json", + "decorators": [], + "kind": "method", + "name": "test_load_collection_reads_json", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::class:VisualizeTest", + "qualified_name": "VisualizeTest.test_load_collection_reads_json", + "signature": "def test_load_collection_reads_json(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 40, + "span": { + "end": { + "byte": 1302, + "column": 69, + "line": 40 + }, + "start": { + "byte": 998, + "column": 4, + "line": 36 + } + }, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_json", + "identity": "VisualizeTest.test_load_collection_reads_json", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_repo_collection_point/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::method:VisualizeTest.test_load_collection_reads_repo_collection_point", + "metadata_kind": "comment", + "text": "Canonical collection requests no expected blocks; this says nothing\nabout native coverage. Synthetic gap rendering is tested separately." + } + }, + "origin": "native", + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 117, + "span": { + "end": { + "byte": 4673, + "column": 78, + "line": 117 + }, + "start": { + "byte": 4525, + "column": 8, + "line": 116 + } + }, + "start_line": 116 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_repo_collection_point", + "identity": "VisualizeTest.test_load_collection_reads_repo_collection_point", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_repo_collection_point/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VisualizeTest.test_load_collection_reads_repo_collection_point", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::method:VisualizeTest.test_load_collection_reads_repo_collection_point", + "decorators": [], + "kind": "method", + "name": "test_load_collection_reads_repo_collection_point", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::class:VisualizeTest", + "qualified_name": "VisualizeTest.test_load_collection_reads_repo_collection_point", + "signature": "def test_load_collection_reads_repo_collection_point(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 119, + "span": { + "end": { + "byte": 4788, + "column": 65, + "line": 119 + }, + "start": { + "byte": 4153, + "column": 4, + "line": 109 + } + }, + "start_line": 109 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_reads_repo_collection_point", + "identity": "VisualizeTest.test_load_collection_reads_repo_collection_point", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_rejects_non_collection_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VisualizeTest.test_load_collection_rejects_non_collection_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::method:VisualizeTest.test_load_collection_rejects_non_collection_text", + "decorators": [], + "kind": "method", + "name": "test_load_collection_rejects_non_collection_text", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::class:VisualizeTest", + "qualified_name": "VisualizeTest.test_load_collection_rejects_non_collection_text", + "signature": "def test_load_collection_rejects_non_collection_text(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 126, + "span": { + "end": { + "byte": 5111, + "column": 37, + "line": 126 + }, + "start": { + "byte": 4794, + "column": 4, + "line": 121 + } + }, + "start_line": 121 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_load_collection_rejects_non_collection_text", + "identity": "VisualizeTest.test_load_collection_rejects_non_collection_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_render_mermaid_contains_repo_edges_and_gaps/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VisualizeTest.test_render_mermaid_contains_repo_edges_and_gaps", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::method:VisualizeTest.test_render_mermaid_contains_repo_edges_and_gaps", + "decorators": [], + "kind": "method", + "name": "test_render_mermaid_contains_repo_edges_and_gaps", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::class:VisualizeTest", + "qualified_name": "VisualizeTest.test_render_mermaid_contains_repo_edges_and_gaps", + "signature": "def test_render_mermaid_contains_repo_edges_and_gaps(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 5572, + "column": 68, + "line": 135 + }, + "start": { + "byte": 5117, + "column": 4, + "line": 128 + } + }, + "start_line": 128 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_render_mermaid_contains_repo_edges_and_gaps", + "identity": "VisualizeTest.test_render_mermaid_contains_repo_edges_and_gaps", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_render_mermaid_keeps_same_entry_id_in_two_files_distinct/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VisualizeTest.test_render_mermaid_keeps_same_entry_id_in_two_files_distinct", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::method:VisualizeTest.test_render_mermaid_keeps_same_entry_id_in_two_files_distinct", + "decorators": [], + "kind": "method", + "name": "test_render_mermaid_keeps_same_entry_id_in_two_files_distinct", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::class:VisualizeTest", + "qualified_name": "VisualizeTest.test_render_mermaid_keeps_same_entry_id_in_two_files_distinct", + "signature": "def test_render_mermaid_keeps_same_entry_id_in_two_files_distinct(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 155, + "span": { + "end": { + "byte": 6532, + "column": 131, + "line": 155 + }, + "start": { + "byte": 5578, + "column": 4, + "line": 137 + } + }, + "start_line": 137 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest.test_render_mermaid_keeps_same_entry_id_in_two_files_distinct", + "identity": "VisualizeTest.test_render_mermaid_keeps_same_entry_id_in_two_files_distinct", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "VisualizeTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_visualize.py::class:VisualizeTest", + "decorators": [], + "kind": "class", + "name": "VisualizeTest", + "parent_identity": null, + "qualified_name": "VisualizeTest", + "signature": "class VisualizeTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c80e92334dfb2ab8b48de37653b9715dfa25db89ff48c54b67cda6ac0e4d2205", + "file": "tests/test_visualize.py", + "location": { + "end_line": 155, + "span": { + "end": { + "byte": 6532, + "column": 131, + "line": 155 + }, + "start": { + "byte": 222, + "column": 0, + "line": 12 + } + }, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_visualize.py#subject/symbol/VisualizeTest", + "identity": "VisualizeTest", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_vm_mcp.py::<module>", + "metadata_kind": "comment", + "text": "noqa: E402,F401" + } + }, + "origin": "native", + "source": { + "content_sha256": "52332c589708425765027d2e8ca94953e006e5400fd0d289095793fc184bcd2f", + "file": "tests/test_vm_mcp.py", + "location": { + "end_line": 21, + "span": { + "end": { + "byte": 650, + "column": 58, + "line": 21 + }, + "start": { + "byte": 633, + "column": 41, + "line": 21 + } + }, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "identity": "tests/test_vm_mcp.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_vm_mcp.py::<module>", + "metadata_kind": "comment", + "text": "noqa: E402,F401" + } + }, + "origin": "native", + "source": { + "content_sha256": "52332c589708425765027d2e8ca94953e006e5400fd0d289095793fc184bcd2f", + "file": "tests/test_vm_mcp.py", + "location": { + "end_line": 22, + "span": { + "end": { + "byte": 710, + "column": 59, + "line": 22 + }, + "start": { + "byte": 693, + "column": 42, + "line": 22 + } + }, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "identity": "tests/test_vm_mcp.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_vm_mcp.py::<module>", + "description": "Usage guidance:\n python -m unittest discover -s tests\n\nThe canonical tests remain beside the skill under ``vm-mcp/tests``. This root\nadapter only imports those TestCase classes so the existing repository CI gate\nexecutes them without duplicating assertions.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Expose vm-mcp's self-contained unittest suites to skill-lib root CI discovery.", + "text": "Expose vm-mcp's self-contained unittest suites to skill-lib root CI discovery.\n\nUsage guidance:\n python -m unittest discover -s tests\n\nThe canonical tests remain beside the skill under ``vm-mcp/tests``. This root\nadapter only imports those TestCase classes so the existing repository CI gate\nexecutes them without duplicating assertions.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "52332c589708425765027d2e8ca94953e006e5400fd0d289095793fc184bcd2f", + "file": "tests/test_vm_mcp.py", + "location": { + "end_line": 9, + "span": { + "end": { + "byte": 347, + "column": 3, + "line": 9 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "identity": "tests/test_vm_mcp.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "52332c589708425765027d2e8ca94953e006e5400fd0d289095793fc184bcd2f", + "file": "tests/test_vm_mcp.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "identity": "tests/test_vm_mcp.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "52332c589708425765027d2e8ca94953e006e5400fd0d289095793fc184bcd2f", + "file": "tests/test_vm_mcp.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "identity": "tests/test_vm_mcp.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "52332c589708425765027d2e8ca94953e006e5400fd0d289095793fc184bcd2f", + "file": "tests/test_vm_mcp.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "identity": "tests/test_vm_mcp.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "test_assets:VmMcpAssetTests:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "test_assets", + "name": "VmMcpAssetTests" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "52332c589708425765027d2e8ca94953e006e5400fd0d289095793fc184bcd2f", + "file": "tests/test_vm_mcp.py", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "identity": "tests/test_vm_mcp.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "test_policy:VmMcpPolicyTests:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "test_policy", + "name": "VmMcpPolicyTests" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "52332c589708425765027d2e8ca94953e006e5400fd0d289095793fc184bcd2f", + "file": "tests/test_vm_mcp.py", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_vm_mcp.py#subject/module/tests%2Ftest_vm_mcp.py", + "identity": "tests/test_vm_mcp.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ea04b94251a567ced5bb336316b17e30f9647047adcccc89b3a6ecdac67f7c0b", + "file": "tests/test_website_builder_journal_skill.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py", + "identity": "tests/test_website_builder_journal_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ea04b94251a567ced5bb336316b17e30f9647047adcccc89b3a6ecdac67f7c0b", + "file": "tests/test_website_builder_journal_skill.py", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py", + "identity": "tests/test_website_builder_journal_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ea04b94251a567ced5bb336316b17e30f9647047adcccc89b3a6ecdac67f7c0b", + "file": "tests/test_website_builder_journal_skill.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py", + "identity": "tests/test_website_builder_journal_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ea04b94251a567ced5bb336316b17e30f9647047adcccc89b3a6ecdac67f7c0b", + "file": "tests/test_website_builder_journal_skill.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/module/tests%2Ftest_website_builder_journal_skill.py", + "identity": "tests/test_website_builder_journal_skill.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/symbol/WebsiteBuilderJournalSkillTest.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "WebsiteBuilderJournalSkillTest.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_website_builder_journal_skill.py::method:WebsiteBuilderJournalSkillTest.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_website_builder_journal_skill.py::class:WebsiteBuilderJournalSkillTest", + "qualified_name": "WebsiteBuilderJournalSkillTest.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ea04b94251a567ced5bb336316b17e30f9647047adcccc89b3a6ecdac67f7c0b", + "file": "tests/test_website_builder_journal_skill.py", + "location": { + "end_line": 15, + "span": { + "end": { + "byte": 424, + "column": 66, + "line": 15 + }, + "start": { + "byte": 279, + "column": 4, + "line": 13 + } + }, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/symbol/WebsiteBuilderJournalSkillTest.setUp", + "identity": "WebsiteBuilderJournalSkillTest.setUp", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/symbol/WebsiteBuilderJournalSkillTest.test_contract_is_append_only_and_model_discretionary/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "WebsiteBuilderJournalSkillTest.test_contract_is_append_only_and_model_discretionary", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_website_builder_journal_skill.py::method:WebsiteBuilderJournalSkillTest.test_contract_is_append_only_and_model_discretionary", + "decorators": [], + "kind": "method", + "name": "test_contract_is_append_only_and_model_discretionary", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_website_builder_journal_skill.py::class:WebsiteBuilderJournalSkillTest", + "qualified_name": "WebsiteBuilderJournalSkillTest.test_contract_is_append_only_and_model_discretionary", + "signature": "def test_contract_is_append_only_and_model_discretionary(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ea04b94251a567ced5bb336316b17e30f9647047adcccc89b3a6ecdac67f7c0b", + "file": "tests/test_website_builder_journal_skill.py", + "location": { + "end_line": 40, + "span": { + "end": { + "byte": 1703, + "column": 48, + "line": 40 + }, + "start": { + "byte": 985, + "column": 4, + "line": 24 + } + }, + "start_line": 24 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/symbol/WebsiteBuilderJournalSkillTest.test_contract_is_append_only_and_model_discretionary", + "identity": "WebsiteBuilderJournalSkillTest.test_contract_is_append_only_and_model_discretionary", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/symbol/WebsiteBuilderJournalSkillTest.test_historical_entry_migration_is_fail_closed/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "WebsiteBuilderJournalSkillTest.test_historical_entry_migration_is_fail_closed", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_website_builder_journal_skill.py::method:WebsiteBuilderJournalSkillTest.test_historical_entry_migration_is_fail_closed", + "decorators": [], + "kind": "method", + "name": "test_historical_entry_migration_is_fail_closed", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_website_builder_journal_skill.py::class:WebsiteBuilderJournalSkillTest", + "qualified_name": "WebsiteBuilderJournalSkillTest.test_historical_entry_migration_is_fail_closed", + "signature": "def test_historical_entry_migration_is_fail_closed(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ea04b94251a567ced5bb336316b17e30f9647047adcccc89b3a6ecdac67f7c0b", + "file": "tests/test_website_builder_journal_skill.py", + "location": { + "end_line": 44, + "span": { + "end": { + "byte": 1927, + "column": 92, + "line": 44 + }, + "start": { + "byte": 1709, + "column": 4, + "line": 42 + } + }, + "start_line": 42 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/symbol/WebsiteBuilderJournalSkillTest.test_historical_entry_migration_is_fail_closed", + "identity": "WebsiteBuilderJournalSkillTest.test_historical_entry_migration_is_fail_closed", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/symbol/WebsiteBuilderJournalSkillTest.test_registered_as_procedural_with_exact_trigger/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "WebsiteBuilderJournalSkillTest.test_registered_as_procedural_with_exact_trigger", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_website_builder_journal_skill.py::method:WebsiteBuilderJournalSkillTest.test_registered_as_procedural_with_exact_trigger", + "decorators": [], + "kind": "method", + "name": "test_registered_as_procedural_with_exact_trigger", + "parent_identity": "python:The-Interdependency/skill-lib:tests/test_website_builder_journal_skill.py::class:WebsiteBuilderJournalSkillTest", + "qualified_name": "WebsiteBuilderJournalSkillTest.test_registered_as_procedural_with_exact_trigger", + "signature": "def test_registered_as_procedural_with_exact_trigger(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ea04b94251a567ced5bb336316b17e30f9647047adcccc89b3a6ecdac67f7c0b", + "file": "tests/test_website_builder_journal_skill.py", + "location": { + "end_line": 22, + "span": { + "end": { + "byte": 979, + "column": 84, + "line": 22 + }, + "start": { + "byte": 430, + "column": 4, + "line": 17 + } + }, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/symbol/WebsiteBuilderJournalSkillTest.test_registered_as_procedural_with_exact_trigger", + "identity": "WebsiteBuilderJournalSkillTest.test_registered_as_procedural_with_exact_trigger", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/symbol/WebsiteBuilderJournalSkillTest/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "WebsiteBuilderJournalSkillTest", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tests/test_website_builder_journal_skill.py::class:WebsiteBuilderJournalSkillTest", + "decorators": [], + "kind": "class", + "name": "WebsiteBuilderJournalSkillTest", + "parent_identity": null, + "qualified_name": "WebsiteBuilderJournalSkillTest", + "signature": "class WebsiteBuilderJournalSkillTest(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ea04b94251a567ced5bb336316b17e30f9647047adcccc89b3a6ecdac67f7c0b", + "file": "tests/test_website_builder_journal_skill.py", + "location": { + "end_line": 44, + "span": { + "end": { + "byte": 1927, + "column": 92, + "line": 44 + }, + "start": { + "byte": 218, + "column": 0, + "line": 12 + } + }, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tests/test_website_builder_journal_skill.py#subject/symbol/WebsiteBuilderJournalSkillTest", + "identity": "WebsiteBuilderJournalSkillTest", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/the-interdependency/SKILL.md#subject/document/the-interdependency%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Protocol and workflow for all tasks involving The Interdependency organization, its repositories, The Interdependent Way projects, EDCMBONE transcript analysis, code building, research, GitHub maintenance and updates. Load this whenever the task or context touches The-Interdependency assets, or on phrases like \"assemble edcmbone transcripts for analysis\", \"write code that...\", or any GitHub/research/build work on org projects.", + "name": "the-interdependency" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "d3a92b21eb332d68304ba0a29087df9d5c002053e30a04097ac8aa7612525da5", + "file": "the-interdependency/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/the-interdependency/SKILL.md#subject/document/the-interdependency%2FSKILL.md", + "identity": "the-interdependency/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/thought-lens/SKILL.md#subject/document/thought-lens%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Translate raw, context-heavy, recursive, fragmentary, coined, or private-language thought into audience-legible language without changing the underlying claim. Load this when a user says people do not understand what they mean; asks to make a thought understandable to strangers, the public, a specific audience, or a platform; supplies dense notes rather than finished prose; needs jargon or coined terms introduced only after their ordinary-language meaning lands; or wants multiple audience/surface renderings from one thought. Do not load merely to polish finished prose or to simplify an already-stable canonical document; use ordinary editing for the former and plain-lens for the latter.", + "name": "thought-lens" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "bb425468da1a053a32cb89a3d85d4e4d6e7fc953c70610c6c886c028e3bc63df", + "file": "thought-lens/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/thought-lens/SKILL.md#subject/document/thought-lens%2FSKILL.md", + "identity": "thought-lens/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/thought-lens/fixtures.json#subject/document/thought-lens%2Ffixtures.json/fact/structured-document/lines%3A%3F-%3F", + "convention": { + "dialect": "json", + "namespace": "json.document", + "version": "RFC 8259" + }, + "extraction": { + "configuration_sha256": "894d1c62fa05bbff60211e5b2d50e7557433c32ad26c40b55e701ddd904cdcaa", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "structured-document", + "native": { + "id": null, + "value": { + "description": "Human/model review fixtures for thought-lens. They test claim recovery, context-gap reduction, status preservation, and refusal to invent bridges. They are not proof that a human audience will understand a rendering.", + "fixtures": [ + { + "audience": "context-light adult stranger", + "expected_claim_type": "distinction", + "id": "topology-vs-authority", + "must_not_imply": [ + "the system has only one physical node", + "all centralized permission systems are bad" + ], + "must_preserve": [ + "many nodes do not by themselves imply distributed authority", + "a shared permission service can remain a central authority", + "topology and authority are distinct properties" + ], + "source": "A network gets called decentralized because there are many nodes, but if every node must ask the same service who is allowed to speak, the authority is still centralized. topology isn't authority.", + "surface": "conversation" + }, + { + "audience": "engineer", + "expected_claim_type": "observation_plus_hypothesis", + "id": "uncertainty-preservation", + "must_not_imply": [ + "handoff context loss has been proven", + "compression is the cause" + ], + "must_preserve": [ + "failures are observed after handoff", + "handoff context loss is a suspicion rather than an established cause", + "three candidate causes remain unresolved" + ], + "source": "I keep seeing the failures happen after the handoff. I suspect the handoff is where context is being lost, but I don't know whether the cause is compression, permissions, or the receiving agent.", + "surface": "technical" + }, + { + "audience": "stranger", + "expected_claim_type": "definition", + "id": "coined-term-after-meaning", + "must_not_imply": [ + "hmmm means confusion in general", + "unfinished work is complete" + ], + "must_preserve": [ + "the unresolved constraint remains visible", + "the marker separates delivered work from unfinished continuation", + "hmmm is the coined label" + ], + "source": "I call a durable unresolved constraint hmmm. It marks the place where delivered work ends without pretending the unfinished part vanished.", + "surface": "short_public_post" + }, + { + "audience": "developer", + "expected_claim_type": "normative_constraint", + "id": "operator-preservation", + "must_not_imply": [ + "self-checks are forbidden", + "a model self-check qualifies as external measurement" + ], + "must_preserve": [ + "external evaluation is required for the measured label", + "self-checks are allowed only under the self-check label" + ], + "source": "No model may publish the result as measured unless an external evaluator actually ran; a self-check may only be labeled a self-check.", + "surface": "technical" + }, + { + "audience": "developer", + "expected_claim_type": "implementation_observation", + "id": "do-not-overrecover", + "must_not_imply": [ + "a theory of identity", + "a general security guarantee", + "a reason why unsigned requests are rejected" + ], + "must_preserve": [ + "the current implementation rejects unsigned requests" + ], + "should_not_activate_deep_recovery": true, + "source": "The current implementation rejects unsigned requests.", + "surface": "technical" + } + ], + "review_questions": [ + "Can a reader state the kernel without seeing the source?", + "Did any modal, negation, quantifier, actor, condition, exception, causal strength, or claim status change?", + "Did the rendering add a substantive claim that the source did not license?", + "Did a coined term carry argumentative weight before its ordinary-language referent was available?", + "Is every unresolved bridge still visible as hmmm rather than silently completed?" + ], + "version": 1 + } + }, + "origin": "native", + "source": { + "content_sha256": "97518234e1d6ff442262d993f5d1393f64540bb4cb256ecc31a7421e05b82eda", + "file": "thought-lens/fixtures.json", + "location": { + "pointer": "" + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/thought-lens/fixtures.json#subject/document/thought-lens%2Ffixtures.json", + "identity": "thought-lens/fixtures.json", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A2-2/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "66:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A258-258/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "66:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 258, + "start_line": 258 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A2-2/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "7:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A258-258/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "7:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 258, + "start_line": 258 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A2-2/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "162:55" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A258-258/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "162:55" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 258, + "start_line": 258 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::<module>", + "metadata_kind": "shebang", + "text": "!/usr/bin/env python3" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 22, + "column": 22, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=162:55 imports_exports=7:11 calls_definitions=66:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 2, + "span": { + "end": { + "byte": 97, + "column": 74, + "line": 2 + }, + "start": { + "byte": 23, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: org_rec_aggregation_runner\n module_name: aggregate_org_rec\n module_kind: instrument\n summary: append repo-local rec.md recommendations into an org-level rec.md section.\n owner: Codex\n public_surface: build_report, append_report, command line\n internal_surface: discover_repos, extract_section, git_value\n auth_boundary: none\n storage_boundary: write\n network_boundary: none\n user_data_boundary: none\n admin_only: false\n tests: tests/test_org_reports.py\n rollout: manual runner under tools\n rollback: remove tool and README entry\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 43, + "span": { + "end": { + "byte": 1691, + "column": 26, + "line": 43 + }, + "start": { + "byte": 1065, + "column": 0, + "line": 27 + } + }, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CONTRACTS ===\nid: org_rec_append_only\n given: append_report is called for an existing aggregate file\n then: existing bytes remain before the new report and the file is not truncated\n class: filesystem\n\nid: org_rec_missing_repo_visible\n given: a discovered git checkout has no rec.md\n then: the aggregate includes the repository in a visible hmmm/missing list\n class: evidence\n\nid: org_rec_remaining_fallback\n given: a repo's latest rec.md block has Remaining but no Recommendations\n then: the aggregate reports the Remaining bullets as follow-up recommendations\n class: evidence\n=== END CONTRACTS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 60, + "span": { + "end": { + "byte": 2336, + "column": 23, + "line": 60 + }, + "start": { + "byte": 1693, + "column": 0, + "line": 45 + } + }, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=162:55 imports_exports=7:11 calls_definitions=66:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 258, + "span": { + "end": { + "byte": 9396, + "column": 74, + "line": 258 + }, + "start": { + "byte": 9322, + "column": 0, + "line": 258 + } + }, + "start_line": 258 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::<module>", + "description": "Usage guidance:\n python3 tools/aggregate_org_rec.py --root .. --out ../rec.md\n python3 tools/aggregate_org_rec.py --root .. --out ../rec.md --append\n python3 tools/aggregate_org_rec.py --root .. --out ../rec.md --strict\n\nThe runner discovers immediate child git checkouts under ``--root``, reads each\nrepo's ``rec.md``, extracts its latest ``### Recommendations`` section, falls\nback to the latest ``### Remaining`` section for repair-pass records, carries\n``### hmmm`` forward when present, and emits one timestamped aggregation\nsection. With ``--append`` it opens the aggregate output in append mode only. It\nnever edits repo-local ``rec.md`` files and never truncates the aggregate.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Append repo-local recommendations into one org-level ``rec.md``.", + "text": "Append repo-local recommendations into one org-level ``rec.md``.\n\nUsage guidance:\n python3 tools/aggregate_org_rec.py --root .. --out ../rec.md\n python3 tools/aggregate_org_rec.py --root .. --out ../rec.md --append\n python3 tools/aggregate_org_rec.py --root .. --out ../rec.md --strict\n\nThe runner discovers immediate child git checkouts under ``--root``, reads each\nrepo's ``rec.md``, extracts its latest ``### Recommendations`` section, falls\nback to the latest ``### Remaining`` section for repair-pass records, carries\n``### hmmm`` forward when present, and emits one timestamped aggregation\nsection. With ``--append`` it opens the aggregate output in append mode only. It\nnever edits repo-local ``rec.md`` files and never truncates the aggregate.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 16, + "span": { + "end": { + "byte": 865, + "column": 3, + "line": 16 + }, + "start": { + "byte": 98, + "column": 0, + "line": 3 + } + }, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "dataclasses:dataclass:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "dataclasses", + "name": "dataclass" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "datetime:datetime:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "datetime", + "name": "datetime" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 23, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "datetime:timezone:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "datetime", + "name": "timezone" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 23, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 24, + "start_line": 24 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterable:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 25, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/module/tools%2Faggregate_org_rec.py", + "identity": "tools/aggregate_org_rec.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/RepoRec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "RepoRec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::class:RepoRec", + "decorators": [ + "dataclass(frozen=True)" + ], + "kind": "class", + "name": "RepoRec", + "parent_identity": null, + "qualified_name": "RepoRec", + "signature": "class RepoRec" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 73, + "span": { + "end": { + "byte": 2560, + "column": 19, + "line": 73 + }, + "start": { + "byte": 2391, + "column": 0, + "line": 65 + } + }, + "start_line": 65 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/RepoRec", + "identity": "RepoRec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/_relative/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_relative", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:_relative", + "decorators": [], + "kind": "function", + "name": "_relative", + "parent_identity": null, + "qualified_name": "_relative", + "signature": "def _relative(path: Path, root: Path) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 160, + "span": { + "end": { + "byte": 5451, + "column": 24, + "line": 160 + }, + "start": { + "byte": 5300, + "column": 0, + "line": 156 + } + }, + "start_line": 156 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/_relative", + "identity": "_relative", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/append_report/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "append_report", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:append_report", + "decorators": [], + "kind": "function", + "name": "append_report", + "parent_identity": null, + "qualified_name": "append_report", + "signature": "def append_report(out: Path, report: str) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 232, + "span": { + "end": { + "byte": 8293, + "column": 26, + "line": 232 + }, + "start": { + "byte": 7856, + "column": 0, + "line": 223 + } + }, + "start_line": 223 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/append_report", + "identity": "append_report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/append_report/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:append_report", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Append one report section without truncating existing content.", + "text": "Append one report section without truncating existing content." + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 224, + "span": { + "end": { + "byte": 7979, + "column": 72, + "line": 224 + }, + "start": { + "byte": 7911, + "column": 4, + "line": 224 + } + }, + "start_line": 224 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/append_report", + "identity": "append_report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/build_report/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "build_report", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:build_report", + "decorators": [], + "kind": "function", + "name": "build_report", + "parent_identity": null, + "qualified_name": "build_report", + "signature": "def build_report(root: Path=DEFAULT_ROOT, generated_at: str | None=None) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 220, + "span": { + "end": { + "byte": 7853, + "column": 27, + "line": 220 + }, + "start": { + "byte": 5454, + "column": 0, + "line": 163 + } + }, + "start_line": 163 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/build_report", + "identity": "build_report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/build_report/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:build_report", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Build one aggregate markdown section without writing it.", + "text": "Build one aggregate markdown section without writing it." + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 164, + "span": { + "end": { + "byte": 5605, + "column": 66, + "line": 164 + }, + "start": { + "byte": 5543, + "column": 4, + "line": 164 + } + }, + "start_line": 164 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/build_report", + "identity": "build_report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/discover_repos/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "discover_repos", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:discover_repos", + "decorators": [], + "kind": "function", + "name": "discover_repos", + "parent_identity": null, + "qualified_name": "discover_repos", + "signature": "def discover_repos(root: Path) -> list[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 97, + "span": { + "end": { + "byte": 3430, + "column": 60, + "line": 97 + }, + "start": { + "byte": 3123, + "column": 0, + "line": 93 + } + }, + "start_line": 93 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/discover_repos", + "identity": "discover_repos", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/discover_repos/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:discover_repos", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Discover immediate child git checkouts and worktrees under ``root``.", + "text": "Discover immediate child git checkouts and worktrees under ``root``." + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 94, + "span": { + "end": { + "byte": 3247, + "column": 78, + "line": 94 + }, + "start": { + "byte": 3173, + "column": 4, + "line": 94 + } + }, + "start_line": 94 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/discover_repos", + "identity": "discover_repos", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/extract_recommendations/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "extract_recommendations", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:extract_recommendations", + "decorators": [], + "kind": "function", + "name": "extract_recommendations", + "parent_identity": null, + "qualified_name": "extract_recommendations", + "signature": "def extract_recommendations(block: Iterable[str]) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 131, + "span": { + "end": { + "byte": 4557, + "column": 91, + "line": 131 + }, + "start": { + "byte": 4290, + "column": 0, + "line": 128 + } + }, + "start_line": 128 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/extract_recommendations", + "identity": "extract_recommendations", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/extract_recommendations/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:extract_recommendations", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Extract recommendations from the latest block, accepting repair-pass wording.", + "text": "Extract recommendations from the latest block, accepting repair-pass wording." + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 129, + "span": { + "end": { + "byte": 4441, + "column": 87, + "line": 129 + }, + "start": { + "byte": 4358, + "column": 4, + "line": 129 + } + }, + "start_line": 129 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/extract_recommendations", + "identity": "extract_recommendations", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/extract_section/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "extract_section", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:extract_section", + "decorators": [], + "kind": "function", + "name": "extract_section", + "parent_identity": null, + "qualified_name": "extract_section", + "signature": "def extract_section(block: Iterable[str], heading: str) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 125, + "span": { + "end": { + "byte": 4287, + "column": 14, + "line": 125 + }, + "start": { + "byte": 3735, + "column": 0, + "line": 109 + } + }, + "start_line": 109 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/extract_section", + "identity": "extract_section", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/extract_section/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:extract_section", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Extract a ``### <heading>`` section from one markdown block.", + "text": "Extract a ``### <heading>`` section from one markdown block." + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 110, + "span": { + "end": { + "byte": 3875, + "column": 70, + "line": 110 + }, + "start": { + "byte": 3809, + "column": 4, + "line": 110 + } + }, + "start_line": 110 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/extract_section", + "identity": "extract_section", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/git_value/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "git_value", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:git_value", + "decorators": [], + "kind": "function", + "name": "git_value", + "parent_identity": null, + "qualified_name": "git_value", + "signature": "def git_value(repo: Path, *args: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 90, + "span": { + "end": { + "byte": 3120, + "column": 21, + "line": 90 + }, + "start": { + "byte": 2737, + "column": 0, + "line": 81 + } + }, + "start_line": 81 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/git_value", + "identity": "git_value", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/git_value/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:git_value", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Read one git value; return ``hmmm`` when the checkout cannot answer.", + "text": "Read one git value; return ``hmmm`` when the checkout cannot answer." + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 82, + "span": { + "end": { + "byte": 2861, + "column": 78, + "line": 82 + }, + "start": { + "byte": 2787, + "column": 4, + "line": 82 + } + }, + "start_line": 82 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/git_value", + "identity": "git_value", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/latest_block/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "latest_block", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:latest_block", + "decorators": [], + "kind": "function", + "name": "latest_block", + "parent_identity": null, + "qualified_name": "latest_block", + "signature": "def latest_block(text: str) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 106, + "span": { + "end": { + "byte": 3732, + "column": 30, + "line": 106 + }, + "start": { + "byte": 3433, + "column": 0, + "line": 100 + } + }, + "start_line": 100 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/latest_block", + "identity": "latest_block", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/latest_block/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:latest_block", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return the last markdown ``##`` block, or all lines if no block exists.", + "text": "Return the last markdown ``##`` block, or all lines if no block exists." + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 101, + "span": { + "end": { + "byte": 3556, + "column": 81, + "line": 101 + }, + "start": { + "byte": 3479, + "column": 4, + "line": 101 + } + }, + "start_line": 101 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/latest_block", + "identity": "latest_block", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: list[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 253, + "span": { + "end": { + "byte": 9263, + "column": 46, + "line": 253 + }, + "start": { + "byte": 8296, + "column": 0, + "line": 235 + } + }, + "start_line": 235 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/now_utc/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "now_utc", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:now_utc", + "decorators": [], + "kind": "function", + "name": "now_utc", + "parent_identity": null, + "qualified_name": "now_utc", + "signature": "def now_utc() -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 78, + "span": { + "end": { + "byte": 2734, + "column": 90, + "line": 78 + }, + "start": { + "byte": 2563, + "column": 0, + "line": 76 + } + }, + "start_line": 76 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/now_utc", + "identity": "now_utc", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/now_utc/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:now_utc", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return an ISO UTC timestamp for report sections.", + "text": "Return an ISO UTC timestamp for report sections." + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 77, + "span": { + "end": { + "byte": 2643, + "column": 58, + "line": 77 + }, + "start": { + "byte": 2589, + "column": 4, + "line": 77 + } + }, + "start_line": 77 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/now_utc", + "identity": "now_utc", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/read_repo_rec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_repo_rec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:read_repo_rec", + "decorators": [], + "kind": "function", + "name": "read_repo_rec", + "parent_identity": null, + "qualified_name": "read_repo_rec", + "signature": "def read_repo_rec(repo: Path) -> RepoRec" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 153, + "span": { + "end": { + "byte": 5297, + "column": 5, + "line": 153 + }, + "start": { + "byte": 4560, + "column": 0, + "line": 134 + } + }, + "start_line": 134 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/read_repo_rec", + "identity": "read_repo_rec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/read_repo_rec/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/aggregate_org_rec.py::function:read_repo_rec", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Read one repo's recommendation file into the aggregate shape.", + "text": "Read one repo's recommendation file into the aggregate shape." + } + }, + "origin": "native", + "source": { + "content_sha256": "4978856f15bfcb86ab9caba2663fbc5ecaf3efdee0ce8cf2ba175387eb93d381", + "file": "tools/aggregate_org_rec.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 4673, + "column": 71, + "line": 135 + }, + "start": { + "byte": 4606, + "column": 4, + "line": 135 + } + }, + "start_line": 135 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/aggregate_org_rec.py#subject/symbol/read_repo_rec", + "identity": "read_repo_rec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b11bce0772f12eb320c52fc2abf81b4eaae2ba6a12b70a099cf13c0d6414da3e", + "file": "tools/ai.sh", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A303-303/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b11bce0772f12eb320c52fc2abf81b4eaae2ba6a12b70a099cf13c0d6414da3e", + "file": "tools/ai.sh", + "location": { + "end_line": 303, + "start_line": 303 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b11bce0772f12eb320c52fc2abf81b4eaae2ba6a12b70a099cf13c0d6414da3e", + "file": "tools/ai.sh", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A303-303/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b11bce0772f12eb320c52fc2abf81b4eaae2ba6a12b70a099cf13c0d6414da3e", + "file": "tools/ai.sh", + "location": { + "end_line": 303, + "start_line": 303 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b11bce0772f12eb320c52fc2abf81b4eaae2ba6a12b70a099cf13c0d6414da3e", + "file": "tools/ai.sh", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A303-303/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "b11bce0772f12eb320c52fc2abf81b4eaae2ba6a12b70a099cf13c0d6414da3e", + "file": "tools/ai.sh", + "location": { + "end_line": 303, + "start_line": 303 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/ai.sh#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A2-2/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "54:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A143-143/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "54:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 143, + "start_line": 143 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A2-2/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "5:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A143-143/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "5:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 143, + "start_line": 143 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A2-2/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "108:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A143-143/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "108:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 143, + "start_line": 143 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::<module>", + "metadata_kind": "shebang", + "text": "!/usr/bin/env python3" + } + }, + "origin": "native", + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 22, + "column": 22, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "identity": "tools/build_codex_plugin_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=108:10 imports_exports=5:7 calls_definitions=54:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 2, + "span": { + "end": { + "byte": 95, + "column": 72, + "line": 2 + }, + "start": { + "byte": 23, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "identity": "tools/build_codex_plugin_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=108:10 imports_exports=5:7 calls_definitions=54:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 143, + "span": { + "end": { + "byte": 4991, + "column": 72, + "line": 143 + }, + "start": { + "byte": 4919, + "column": 0, + "line": 143 + } + }, + "start_line": 143 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "identity": "tools/build_codex_plugin_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::<module>", + "description": "Usage guidance:\n python tools/build_codex_plugin_skills.py --check\n python tools/build_codex_plugin_skills.py --apply\n\nCanonical skill doctrine remains in ``<skill-name>/SKILL.md``. Generated files\nunder ``skills/`` contain only discovery metadata and an instruction to load\nthat canonical source. Do not edit generated adapters by hand.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Build thin Codex plugin adapters for every canonical skill-lib skill.", + "text": "Build thin Codex plugin adapters for every canonical skill-lib skill.\n\nUsage guidance:\n python tools/build_codex_plugin_skills.py --check\n python tools/build_codex_plugin_skills.py --apply\n\nCanonical skill doctrine remains in ``<skill-name>/SKILL.md``. Generated files\nunder ``skills/`` contain only discovery metadata and an instruction to load\nthat canonical source. Do not edit generated adapters by hand.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 12, + "span": { + "end": { + "byte": 517, + "column": 3, + "line": 12 + }, + "start": { + "byte": 96, + "column": 0, + "line": 3 + } + }, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "identity": "tools/build_codex_plugin_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "identity": "tools/build_codex_plugin_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "identity": "tools/build_codex_plugin_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "identity": "tools/build_codex_plugin_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "shutil:shutil:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "shutil", + "name": "shutil" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "identity": "tools/build_codex_plugin_skills.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/module/tools%2Fbuild_codex_plugin_skills.py", + "identity": "tools/build_codex_plugin_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/adapter/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "adapter", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::function:adapter", + "decorators": [], + "kind": "function", + "name": "adapter", + "parent_identity": null, + "qualified_name": "adapter", + "signature": "def adapter(skill: dict[str, object]) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 87, + "span": { + "end": { + "byte": 3175, + "column": 5, + "line": 87 + }, + "start": { + "byte": 2666, + "column": 0, + "line": 78 + } + }, + "start_line": 78 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/adapter", + "identity": "adapter", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/apply/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "apply", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::function:apply", + "decorators": [], + "kind": "function", + "name": "apply", + "parent_identity": null, + "qualified_name": "apply", + "signature": "def apply() -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 121, + "span": { + "end": { + "byte": 4370, + "column": 50, + "line": 121 + }, + "start": { + "byte": 3937, + "column": 0, + "line": 112 + } + }, + "start_line": 112 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/apply", + "identity": "apply", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/canonical_frontmatter/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "canonical_frontmatter", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::function:canonical_frontmatter", + "decorators": [], + "kind": "function", + "name": "canonical_frontmatter", + "parent_identity": null, + "qualified_name": "canonical_frontmatter", + "signature": "def canonical_frontmatter(path: Path) -> dict[str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 61, + "span": { + "end": { + "byte": 2090, + "column": 15, + "line": 61 + }, + "start": { + "byte": 804, + "column": 0, + "line": 27 + } + }, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/canonical_frontmatter", + "identity": "canonical_frontmatter", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/canonical_frontmatter/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::function:canonical_frontmatter", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Parse the dependency-free YAML subset used by canonical SKILL.md files.", + "text": "Parse the dependency-free YAML subset used by canonical SKILL.md files." + } + }, + "origin": "native", + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 28, + "span": { + "end": { + "byte": 942, + "column": 81, + "line": 28 + }, + "start": { + "byte": 865, + "column": 4, + "line": 28 + } + }, + "start_line": 28 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/canonical_frontmatter", + "identity": "canonical_frontmatter", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/canonical_metadata/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "canonical_metadata", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::function:canonical_metadata", + "decorators": [], + "kind": "function", + "name": "canonical_metadata", + "parent_identity": null, + "qualified_name": "canonical_metadata", + "signature": "def canonical_metadata(skill: dict[str, object]) -> tuple[str, str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 75, + "span": { + "end": { + "byte": 2663, + "column": 44, + "line": 75 + }, + "start": { + "byte": 2093, + "column": 0, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/canonical_metadata", + "identity": "canonical_metadata", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/drift/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "drift", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::function:drift", + "decorators": [], + "kind": "function", + "name": "drift", + "parent_identity": null, + "qualified_name": "drift", + "signature": "def drift() -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 109, + "span": { + "end": { + "byte": 3934, + "column": 19, + "line": 109 + }, + "start": { + "byte": 3392, + "column": 0, + "line": 98 + } + }, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/drift", + "identity": "drift", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/expected/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "expected", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::function:expected", + "decorators": [], + "kind": "function", + "name": "expected", + "parent_identity": null, + "qualified_name": "expected", + "signature": "def expected() -> dict[Path, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 95, + "span": { + "end": { + "byte": 3389, + "column": 5, + "line": 95 + }, + "start": { + "byte": 3178, + "column": 0, + "line": 90 + } + }, + "start_line": 90 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/expected", + "identity": "expected", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/build_codex_plugin_skills.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main() -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "4cfc9402f05690984b92a1ffcb8d5205cf6a7f670a820f32395456f73dd9750b", + "file": "tools/build_codex_plugin_skills.py", + "location": { + "end_line": 138, + "span": { + "end": { + "byte": 4860, + "column": 12, + "line": 138 + }, + "start": { + "byte": 4373, + "column": 0, + "line": 124 + } + }, + "start_line": 124 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/build_codex_plugin_skills.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "62:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A208-208/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "62:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 208, + "start_line": 208 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "7:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A208-208/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "7:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 208, + "start_line": 208 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "158:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A208-208/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "158:7" + } + }, + "origin": "native", + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 208, + "start_line": 208 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=158:7 imports_exports=7:11 calls_definitions=62:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 73, + "column": 73, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=158:7 imports_exports=7:11 calls_definitions=62:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 208, + "span": { + "end": { + "byte": 7022, + "column": 73, + "line": 208 + }, + "start": { + "byte": 6949, + "column": 0, + "line": 208 + } + }, + "start_line": 208 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::<module>", + "description": "This is not a full natural-language compressor. It is a preservation checker\nfor the minimum fixture set declared in char-compress/fixtures.json.\nIt verifies that a simple deterministic skeleton keeps required flesh,\nfrozen bones, hmmm markers, and forbidden claim strings out of the output.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Executable guardrails for char-compress fixtures.", + "text": "Executable guardrails for char-compress fixtures.\n\nThis is not a full natural-language compressor. It is a preservation checker\nfor the minimum fixture set declared in char-compress/fixtures.json.\nIt verifies that a simple deterministic skeleton keeps required flesh,\nfrozen bones, hmmm markers, and forbidden claim strings out of the output.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 8, + "span": { + "end": { + "byte": 423, + "column": 3, + "line": 8 + }, + "start": { + "byte": 74, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Sequence:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Sequence" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "dataclasses:dataclass:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "dataclasses", + "name": "dataclass" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Dict:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Dict" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:List:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "List" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Mapping:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Mapping" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/module/tools%2Fchar_compress_check.py", + "identity": "tools/char_compress_check.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/Failure/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "Failure", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::class:Failure", + "decorators": [ + "dataclass" + ], + "kind": "class", + "name": "Failure", + "parent_identity": null, + "qualified_name": "Failure", + "signature": "class Failure" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 48, + "span": { + "end": { + "byte": 1651, + "column": 16, + "line": 48 + }, + "start": { + "byte": 1589, + "column": 0, + "line": 45 + } + }, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/Failure", + "identity": "Failure", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/check_fixture/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "check_fixture", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::function:check_fixture", + "decorators": [], + "kind": "function", + "name": "check_fixture", + "parent_identity": null, + "qualified_name": "check_fixture", + "signature": "def check_fixture(fixture: Mapping[str, Any]) -> List[Failure]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 168, + "span": { + "end": { + "byte": 5620, + "column": 19, + "line": 168 + }, + "start": { + "byte": 4614, + "column": 0, + "line": 144 + } + }, + "start_line": 144 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/check_fixture", + "identity": "check_fixture", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/classify_token/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "classify_token", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::function:classify_token", + "decorators": [], + "kind": "function", + "name": "classify_token", + "parent_identity": null, + "qualified_name": "classify_token", + "signature": "def classify_token(token: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 92, + "span": { + "end": { + "byte": 2913, + "column": 18, + "line": 92 + }, + "start": { + "byte": 2261, + "column": 0, + "line": 74 + } + }, + "start_line": 74 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/classify_token", + "identity": "classify_token", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/compress_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "compress_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::function:compress_text", + "decorators": [], + "kind": "function", + "name": "compress_text", + "parent_identity": null, + "qualified_name": "compress_text", + "signature": "def compress_text(text: str) -> Dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 132, + "span": { + "end": { + "byte": 4317, + "column": 19, + "line": 132 + }, + "start": { + "byte": 2916, + "column": 0, + "line": 95 + } + }, + "start_line": 95 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/compress_text", + "identity": "compress_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/contains_item/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "contains_item", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::function:contains_item", + "decorators": [], + "kind": "function", + "name": "contains_item", + "parent_identity": null, + "qualified_name": "contains_item", + "signature": "def contains_item(items: Sequence[str], expected: str) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 137, + "span": { + "end": { + "byte": 4506, + "column": 84, + "line": 137 + }, + "start": { + "byte": 4320, + "column": 0, + "line": 135 + } + }, + "start_line": 135 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/contains_item", + "identity": "contains_item", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/inventory_fingerprint/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "inventory_fingerprint", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::function:inventory_fingerprint", + "decorators": [], + "kind": "function", + "name": "inventory_fingerprint", + "parent_identity": null, + "qualified_name": "inventory_fingerprint", + "signature": "def inventory_fingerprint(token: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 71, + "span": { + "end": { + "byte": 2258, + "column": 23, + "line": 71 + }, + "start": { + "byte": 2059, + "column": 0, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/inventory_fingerprint", + "identity": "inventory_fingerprint", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/load_fixtures/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "load_fixtures", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::function:load_fixtures", + "decorators": [], + "kind": "function", + "name": "load_fixtures", + "parent_identity": null, + "qualified_name": "load_fixtures", + "signature": "def load_fixtures(path: Path) -> List[Mapping[str, Any]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 176, + "span": { + "end": { + "byte": 5892, + "column": 19, + "line": 176 + }, + "start": { + "byte": 5623, + "column": 0, + "line": 171 + } + }, + "start_line": 171 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/load_fixtures", + "identity": "load_fixtures", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: Sequence[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 203, + "span": { + "end": { + "byte": 6890, + "column": 35, + "line": 203 + }, + "start": { + "byte": 5895, + "column": 0, + "line": 179 + } + }, + "start_line": 179 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/normalize_token/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "normalize_token", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::function:normalize_token", + "decorators": [], + "kind": "function", + "name": "normalize_token", + "parent_identity": null, + "qualified_name": "normalize_token", + "signature": "def normalize_token(token: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 61, + "span": { + "end": { + "byte": 2056, + "column": 54, + "line": 61 + }, + "start": { + "byte": 1728, + "column": 0, + "line": 55 + } + }, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/normalize_token", + "identity": "normalize_token", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/normalize_token/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::function:normalize_token", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Normalize punctuation while preserving paths, URLs, and dotted filenames.", + "text": "Normalize punctuation while preserving paths, URLs, and dotted filenames." + } + }, + "origin": "native", + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 56, + "span": { + "end": { + "byte": 1851, + "column": 83, + "line": 56 + }, + "start": { + "byte": 1772, + "column": 4, + "line": 56 + } + }, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/normalize_token", + "identity": "normalize_token", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/skeleton_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "skeleton_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::function:skeleton_text", + "decorators": [], + "kind": "function", + "name": "skeleton_text", + "parent_identity": null, + "qualified_name": "skeleton_text", + "signature": "def skeleton_text(skeleton: Mapping[str, Any]) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 141, + "span": { + "end": { + "byte": 4611, + "column": 47, + "line": 141 + }, + "start": { + "byte": 4509, + "column": 0, + "line": 140 + } + }, + "start_line": 140 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/skeleton_text", + "identity": "skeleton_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/tokenize/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "tokenize", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/char_compress_check.py::function:tokenize", + "decorators": [], + "kind": "function", + "name": "tokenize", + "parent_identity": null, + "qualified_name": "tokenize", + "signature": "def tokenize(text: str) -> List[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "1efb9607215768daec7c8df937f04ed0ba3bc874be3031f0435b52c793dbb11a", + "file": "tools/char_compress_check.py", + "location": { + "end_line": 52, + "span": { + "end": { + "byte": 1725, + "column": 33, + "line": 52 + }, + "start": { + "byte": 1654, + "column": 0, + "line": 51 + } + }, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/char_compress_check.py#subject/symbol/tokenize", + "identity": "tokenize", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "91:16" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A335-335/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "91:16" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 335, + "start_line": 335 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "9:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A335-335/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "9:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 335, + "start_line": 335 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "240:48" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A335-335/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "240:48" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 335, + "start_line": 335 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=240:48 imports_exports=9:12 calls_definitions=91:16" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 74, + "column": 74, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::<module>", + "metadata_kind": "comment", + "text": "GNU sha256sum output line: 64 lowercase hex, one space, one mode char\n(' ' text / '*' binary), then the filename immediately -- no other spacing." + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 52, + "span": { + "end": { + "byte": 2450, + "column": 77, + "line": 52 + }, + "start": { + "byte": 2301, + "column": 0, + "line": 51 + } + }, + "start_line": 51 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::<module>", + "metadata_kind": "comment", + "text": "A skill file linking to a shared doctrine doc, e.g. `../doctrine/msdmd-checks.md`.\nSkills live at `.agents/skills/<skill>/`, so `../doctrine/<f>` resolves to the\nsibling `.agents/skills/doctrine/<f>` -- which must be vendored alongside them." + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 56, + "span": { + "end": { + "byte": 2771, + "column": 81, + "line": 56 + }, + "start": { + "byte": 2524, + "column": 0, + "line": 54 + } + }, + "start_line": 54 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=240:48 imports_exports=9:12 calls_definitions=91:16" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 335, + "span": { + "end": { + "byte": 13098, + "column": 74, + "line": 335 + }, + "start": { + "byte": 13024, + "column": 0, + "line": 335 + } + }, + "start_line": 335 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::<module>", + "description": "Given a checked-out consumer repository, for every skill directory it vendors\nunder ``.agents/skills/`` that also exists in this canonical ``skill-lib``, verify\nthe canonical files match verbatim. The vendored subset is auto-detected as the\nintersection of the consumer's skill directories with the canonical ones, so no\nper-repo configuration is required.\n\nRules (matching org propagation doctrine):\n\n* A canonical file that is missing from, or differs in, the vendored copy is\n ``drift`` (an error). Repo-local additions -- files or directories present in\n the vendored copy but absent from canonical -- are allowed and ignored, so a\n repo may keep local runners, extra skills, or its own README beside the\n canonical assets.\n* Bytecode (``__pycache__`` / ``*.pyc``) is ignored on both sides.\n* When a vendored ``manifest/generate.py.sha256`` companion is present it must\n pin the vendored ``generate.py`` (``sha256sum -c`` semantics); a stale pin is\n drift.\n* Any shared ``doctrine/<file>`` doc a vendored skill links to (e.g.\n ``../doctrine/msdmd-checks.md``) must be vendored at\n ``.agents/skills/doctrine/<file>`` and match canonical; a missing or stale\n referenced doctrine doc is drift too.\n* With ``--sha`` given, the consumer ``.agents/skills/README.md`` should cite that\n canonical source commit; a missing/mismatched citation is a warning (an error\n under ``--strict-sha``).\n\nPure stdlib. No network. Read-only -- it never writes to the consumer repo.\nExit status is ``0`` when clean, ``1`` on drift (or a SHA warning under\n``--strict-sha``, or zero vendored canonical skills under ``--require-vendored``),\n``2`` on a usage error. ``--require-vendored`` is for callers -- like the\nscheduled workflow -- whose targets are known to carry a subset, so an empty\nvendored set is itself a regression.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Detect drift between a consumer repo's vendored skills and canonical skill-lib.", + "text": "Detect drift between a consumer repo's vendored skills and canonical skill-lib.\n\nGiven a checked-out consumer repository, for every skill directory it vendors\nunder ``.agents/skills/`` that also exists in this canonical ``skill-lib``, verify\nthe canonical files match verbatim. The vendored subset is auto-detected as the\nintersection of the consumer's skill directories with the canonical ones, so no\nper-repo configuration is required.\n\nRules (matching org propagation doctrine):\n\n* A canonical file that is missing from, or differs in, the vendored copy is\n ``drift`` (an error). Repo-local additions -- files or directories present in\n the vendored copy but absent from canonical -- are allowed and ignored, so a\n repo may keep local runners, extra skills, or its own README beside the\n canonical assets.\n* Bytecode (``__pycache__`` / ``*.pyc``) is ignored on both sides.\n* When a vendored ``manifest/generate.py.sha256`` companion is present it must\n pin the vendored ``generate.py`` (``sha256sum -c`` semantics); a stale pin is\n drift.\n* Any shared ``doctrine/<file>`` doc a vendored skill links to (e.g.\n ``../doctrine/msdmd-checks.md``) must be vendored at\n ``.agents/skills/doctrine/<file>`` and match canonical; a missing or stale\n referenced doctrine doc is drift too.\n* With ``--sha`` given, the consumer ``.agents/skills/README.md`` should cite that\n canonical source commit; a missing/mismatched citation is a warning (an error\n under ``--strict-sha``).\n\nPure stdlib. No network. Read-only -- it never writes to the consumer repo.\nExit status is ``0`` when clean, ``1`` on drift (or a SHA warning under\n``--strict-sha``, or zero vendored canonical skills under ``--require-vendored``),\n``2`` on a usage error. ``--require-vendored`` is for callers -- like the\nscheduled workflow -- whose targets are known to carry a subset, so an empty\nvendored set is itself a regression.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 35, + "span": { + "end": { + "byte": 1980, + "column": 3, + "line": 35 + }, + "start": { + "byte": 75, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 37, + "start_line": 37 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 39, + "start_line": 39 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:List:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "List" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 46, + "start_line": 46 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 40, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 41, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 42, + "start_line": 42 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 43, + "start_line": 43 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "dataclasses:dataclass:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "dataclasses", + "name": "dataclass" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 44, + "start_line": 44 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "dataclasses:field:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "dataclasses", + "name": "field" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 44, + "start_line": 44 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 45, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterable:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 46, + "start_line": 46 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/module/tools%2Fcheck_consumer_drift.py", + "identity": "tools/check_consumer_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/ConsumerReport.drifted/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "ConsumerReport.drifted", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::method:ConsumerReport.drifted", + "decorators": [ + "property" + ], + "kind": "method", + "name": "drifted", + "parent_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::class:ConsumerReport", + "qualified_name": "ConsumerReport.drifted", + "signature": "def drifted(self) -> List[SkillReport]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 81, + "span": { + "end": { + "byte": 3541, + "column": 51, + "line": 81 + }, + "start": { + "byte": 3436, + "column": 4, + "line": 79 + } + }, + "start_line": 79 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/ConsumerReport.drifted", + "identity": "ConsumerReport.drifted", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/ConsumerReport/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::class:ConsumerReport", + "metadata_kind": "comment", + "text": "referenced-doctrine drift reasons" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 75, + "span": { + "end": { + "byte": 3303, + "column": 90, + "line": 75 + }, + "start": { + "byte": 3268, + "column": 55, + "line": 75 + } + }, + "start_line": 75 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/ConsumerReport", + "identity": "ConsumerReport", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/ConsumerReport/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::class:ConsumerReport", + "metadata_kind": "comment", + "text": "forbidden active vendored skills" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 76, + "span": { + "end": { + "byte": 3395, + "column": 91, + "line": 76 + }, + "start": { + "byte": 3361, + "column": 57, + "line": 76 + } + }, + "start_line": 76 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/ConsumerReport", + "identity": "ConsumerReport", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/ConsumerReport/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "ConsumerReport", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::class:ConsumerReport", + "decorators": [ + "dataclass" + ], + "kind": "class", + "name": "ConsumerReport", + "parent_identity": null, + "qualified_name": "ConsumerReport", + "signature": "class ConsumerReport" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 81, + "span": { + "end": { + "byte": 3541, + "column": 51, + "line": 81 + }, + "start": { + "byte": 3102, + "column": 0, + "line": 71 + } + }, + "start_line": 71 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/ConsumerReport", + "identity": "ConsumerReport", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/SkillReport.ok/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "SkillReport.ok", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::method:SkillReport.ok", + "decorators": [ + "property" + ], + "kind": "method", + "name": "ok", + "parent_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::class:SkillReport", + "qualified_name": "SkillReport.ok", + "signature": "def ok(self) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 68, + "span": { + "end": { + "byte": 3099, + "column": 29, + "line": 68 + }, + "start": { + "byte": 3034, + "column": 4, + "line": 66 + } + }, + "start_line": 66 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/SkillReport.ok", + "identity": "SkillReport.ok", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/SkillReport/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::class:SkillReport", + "metadata_kind": "comment", + "text": "human-readable per-file reasons" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 64, + "span": { + "end": { + "byte": 3028, + "column": 85, + "line": 64 + }, + "start": { + "byte": 2995, + "column": 52, + "line": 64 + } + }, + "start_line": 64 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/SkillReport", + "identity": "SkillReport", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/SkillReport/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "SkillReport", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::class:SkillReport", + "decorators": [ + "dataclass" + ], + "kind": "class", + "name": "SkillReport", + "parent_identity": null, + "qualified_name": "SkillReport", + "signature": "class SkillReport" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 68, + "span": { + "end": { + "byte": 3099, + "column": 29, + "line": 68 + }, + "start": { + "byte": 2899, + "column": 0, + "line": 61 + } + }, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/SkillReport", + "identity": "SkillReport", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/_canon_files/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_canon_files", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:_canon_files", + "decorators": [], + "kind": "function", + "name": "_canon_files", + "parent_identity": null, + "qualified_name": "_canon_files", + "signature": "def _canon_files(skill_dir: Path) -> Iterable[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 112, + "span": { + "end": { + "byte": 4542, + "column": 22, + "line": 112 + }, + "start": { + "byte": 4348, + "column": 0, + "line": 109 + } + }, + "start_line": 109 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/_canon_files", + "identity": "_canon_files", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/_ignored/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_ignored", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:_ignored", + "decorators": [], + "kind": "function", + "name": "_ignored", + "parent_identity": null, + "qualified_name": "_ignored", + "signature": "def _ignored(path: Path) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 85, + "span": { + "end": { + "byte": 3662, + "column": 84, + "line": 85 + }, + "start": { + "byte": 3544, + "column": 0, + "line": 84 + } + }, + "start_line": 84 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/_ignored", + "identity": "_ignored", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/canon_skill_names/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "canon_skill_names", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:canon_skill_names", + "decorators": [], + "kind": "function", + "name": "canon_skill_names", + "parent_identity": null, + "qualified_name": "canon_skill_names", + "signature": "def canon_skill_names(canon_root: Path) -> set[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 93, + "span": { + "end": { + "byte": 3858, + "column": 5, + "line": 93 + }, + "start": { + "byte": 3665, + "column": 0, + "line": 88 + } + }, + "start_line": 88 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/canon_skill_names", + "identity": "canon_skill_names", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_consumer/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:check_consumer", + "metadata_kind": "comment", + "text": "repo-local skill, not part of the canonical set" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 216, + "span": { + "end": { + "byte": 8833, + "column": 71, + "line": 216 + }, + "start": { + "byte": 8784, + "column": 22, + "line": 216 + } + }, + "start_line": 216 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_consumer", + "identity": "check_consumer", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_consumer/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "check_consumer", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:check_consumer", + "decorators": [], + "kind": "function", + "name": "check_consumer", + "parent_identity": null, + "qualified_name": "check_consumer", + "signature": "def check_consumer(consumer_root: Path, canon_root: Path=ROOT, skills_rel: Path=DEFAULT_SKILLS_REL, sha: str | None=None) -> ConsumerReport" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 232, + "span": { + "end": { + "byte": 9514, + "column": 17, + "line": 232 + }, + "start": { + "byte": 7825, + "column": 0, + "line": 191 + } + }, + "start_line": 191 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_consumer", + "identity": "check_consumer", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_doctrine/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:check_doctrine", + "metadata_kind": "comment", + "text": "dangling reference in canonical itself -- skill-lib's problem, not the vendor's" + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 140, + "span": { + "end": { + "byte": 5609, + "column": 103, + "line": 140 + }, + "start": { + "byte": 5528, + "column": 22, + "line": 140 + } + }, + "start_line": 140 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_doctrine", + "identity": "check_doctrine", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_doctrine/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "check_doctrine", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:check_doctrine", + "decorators": [], + "kind": "function", + "name": "check_doctrine", + "parent_identity": null, + "qualified_name": "check_doctrine", + "signature": "def check_doctrine(canon_root: Path, skills_root: Path, vendored_canon: List[str]) -> List[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 146, + "span": { + "end": { + "byte": 5885, + "column": 18, + "line": 146 + }, + "start": { + "byte": 5059, + "column": 0, + "line": 131 + } + }, + "start_line": 131 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_doctrine", + "identity": "check_doctrine", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_doctrine/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:check_doctrine", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Every doctrine doc referenced by a vendored skill must be present + verbatim.", + "text": "Every doctrine doc referenced by a vendored skill must be present + verbatim." + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 132, + "span": { + "end": { + "byte": 5243, + "column": 87, + "line": 132 + }, + "start": { + "byte": 5160, + "column": 4, + "line": 132 + } + }, + "start_line": 132 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_doctrine", + "identity": "check_doctrine", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_manifest_pin/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "check_manifest_pin", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:check_manifest_pin", + "decorators": [], + "kind": "function", + "name": "check_manifest_pin", + "parent_identity": null, + "qualified_name": "check_manifest_pin", + "signature": "def check_manifest_pin(vend_dir: Path) -> List[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 188, + "span": { + "end": { + "byte": 7822, + "column": 13, + "line": 188 + }, + "start": { + "byte": 6401, + "column": 0, + "line": 162 + } + }, + "start_line": 162 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_manifest_pin", + "identity": "check_manifest_pin", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_manifest_pin/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:check_manifest_pin", + "description": "Mirrors ``sha256sum -c`` exactly: the pin must be a single line of the form\n``<64-hex-lowercase> <mode>generate.py`` -- checksum, one space, one mode\ncharacter (``' '`` text / ``'*'`` binary), then the filename immediately,\nwith no extra separators, markers, or lines. A pin with the right digest but\nany deviation (wrong name, extra spaces, doubled marker, extra line) would\nmake the consumer's ``sha256sum -c`` CI fail or check the wrong path, so\n``PIN_LINE_RE`` rejects all of them as drift rather than trusting a loose\ntoken split.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "A vendored generate.py.sha256, if present, must pin generate.py.", + "text": "A vendored generate.py.sha256, if present, must pin generate.py.\n\n Mirrors ``sha256sum -c`` exactly: the pin must be a single line of the form\n ``<64-hex-lowercase> <mode>generate.py`` -- checksum, one space, one mode\n character (``' '`` text / ``'*'`` binary), then the filename immediately,\n with no extra separators, markers, or lines. A pin with the right digest but\n any deviation (wrong name, extra spaces, doubled marker, extra line) would\n make the consumer's ``sha256sum -c`` CI fail or check the wrong path, so\n ``PIN_LINE_RE`` rejects all of them as drift rather than trusting a loose\n token split.\n " + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 173, + "span": { + "end": { + "byte": 7102, + "column": 7, + "line": 173 + }, + "start": { + "byte": 6458, + "column": 4, + "line": 163 + } + }, + "start_line": 163 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/check_manifest_pin", + "identity": "check_manifest_pin", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/diff_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "diff_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:diff_skill", + "decorators": [], + "kind": "function", + "name": "diff_skill", + "parent_identity": null, + "qualified_name": "diff_skill", + "signature": "def diff_skill(canon_dir: Path, vend_dir: Path) -> List[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 159, + "span": { + "end": { + "byte": 6398, + "column": 18, + "line": 159 + }, + "start": { + "byte": 5888, + "column": 0, + "line": 149 + } + }, + "start_line": 149 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/diff_skill", + "identity": "diff_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/diff_skill/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:diff_skill", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Canonical files that are missing from or differ in the vendored copy.", + "text": "Canonical files that are missing from or differ in the vendored copy." + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 150, + "span": { + "end": { + "byte": 6029, + "column": 79, + "line": 150 + }, + "start": { + "byte": 5954, + "column": 4, + "line": 150 + } + }, + "start_line": 150 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/diff_skill", + "identity": "diff_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/format_report/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "format_report", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:format_report", + "decorators": [], + "kind": "function", + "name": "format_report", + "parent_identity": null, + "qualified_name": "format_report", + "signature": "def format_report(report: ConsumerReport, strict_sha: bool, require_vendored: bool=False) -> tuple[str, bool]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 268, + "span": { + "end": { + "byte": 10759, + "column": 46, + "line": 268 + }, + "start": { + "byte": 9517, + "column": 0, + "line": 235 + } + }, + "start_line": 235 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/format_report", + "identity": "format_report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: List[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 330, + "span": { + "end": { + "byte": 12965, + "column": 29, + "line": 330 + }, + "start": { + "byte": 10762, + "column": 0, + "line": 271 + } + }, + "start_line": 271 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/referenced_doctrine/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "referenced_doctrine", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:referenced_doctrine", + "decorators": [], + "kind": "function", + "name": "referenced_doctrine", + "parent_identity": null, + "qualified_name": "referenced_doctrine", + "signature": "def referenced_doctrine(skill_dir: Path) -> set[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 128, + "span": { + "end": { + "byte": 5056, + "column": 15, + "line": 128 + }, + "start": { + "byte": 4678, + "column": 0, + "line": 121 + } + }, + "start_line": 121 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/referenced_doctrine", + "identity": "referenced_doctrine", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/referenced_doctrine/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:referenced_doctrine", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Shared `doctrine/<file>` docs a skill's text files link to.", + "text": "Shared `doctrine/<file>` docs a skill's text files link to." + } + }, + "origin": "native", + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 122, + "span": { + "end": { + "byte": 4801, + "column": 69, + "line": 122 + }, + "start": { + "byte": 4736, + "column": 4, + "line": 122 + } + }, + "start_line": 122 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/referenced_doctrine", + "identity": "referenced_doctrine", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/sha256_of/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "sha256_of", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:sha256_of", + "decorators": [], + "kind": "function", + "name": "sha256_of", + "parent_identity": null, + "qualified_name": "sha256_of", + "signature": "def sha256_of(path: Path) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 118, + "span": { + "end": { + "byte": 4675, + "column": 29, + "line": 118 + }, + "start": { + "byte": 4545, + "column": 0, + "line": 115 + } + }, + "start_line": 115 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/sha256_of", + "identity": "sha256_of", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/superseded_skills/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "superseded_skills", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_consumer_drift.py::function:superseded_skills", + "decorators": [], + "kind": "function", + "name": "superseded_skills", + "parent_identity": null, + "qualified_name": "superseded_skills", + "signature": "def superseded_skills(canon_root: Path) -> dict[str, List[str]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "f714e52f7139c4b6977c9aac8a3d9f47af75b29f3743baa2ef00262789eaa39d", + "file": "tools/check_consumer_drift.py", + "location": { + "end_line": 106, + "span": { + "end": { + "byte": 4345, + "column": 14, + "line": 106 + }, + "start": { + "byte": 3861, + "column": 0, + "line": 96 + } + }, + "start_line": 96 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_consumer_drift.py#subject/symbol/superseded_skills", + "identity": "superseded_skills", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A2-2/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1875f8c9e922642b3707632e93282efe6390b5ae29ab9d1f1d283246ba7868ca", + "file": "tools/check_gonol_authority.sh", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A71-71/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1875f8c9e922642b3707632e93282efe6390b5ae29ab9d1f1d283246ba7868ca", + "file": "tools/check_gonol_authority.sh", + "location": { + "end_line": 71, + "start_line": 71 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A2-2/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1875f8c9e922642b3707632e93282efe6390b5ae29ab9d1f1d283246ba7868ca", + "file": "tools/check_gonol_authority.sh", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A71-71/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1875f8c9e922642b3707632e93282efe6390b5ae29ab9d1f1d283246ba7868ca", + "file": "tools/check_gonol_authority.sh", + "location": { + "end_line": 71, + "start_line": 71 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A2-2/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1875f8c9e922642b3707632e93282efe6390b5ae29ab9d1f1d283246ba7868ca", + "file": "tools/check_gonol_authority.sh", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A71-71/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "1875f8c9e922642b3707632e93282efe6390b5ae29ab9d1f1d283246ba7868ca", + "file": "tools/check_gonol_authority.sh", + "location": { + "end_line": 71, + "start_line": 71 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/tools%2Fcheck_gonol_authority.sh/fact/interpreter/lines%3A1-1/shebang", + "convention": { + "dialect": "sh", + "namespace": "posix.shebang", + "version": "source declaration v1" + }, + "extraction": { + "configuration_sha256": "64715d255639d911f2d3cd2803a93b14b7288f30528cb729d844c119cd1f8637", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "shell-static", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "interpreter", + "native": { + "id": "shebang", + "value": { + "shebang": "/usr/bin/env bash" + } + }, + "origin": "native", + "source": { + "content_sha256": "1875f8c9e922642b3707632e93282efe6390b5ae29ab9d1f1d283246ba7868ca", + "file": "tools/check_gonol_authority.sh", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_gonol_authority.sh#subject/file/tools%2Fcheck_gonol_authority.sh", + "identity": "tools/check_gonol_authority.sh", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "44:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A135-135/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "44:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 135, + "start_line": 135 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "8:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A135-135/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "8:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 135, + "start_line": 135 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "91:6" + } + }, + "origin": "native", + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A135-135/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "91:6" + } + }, + "origin": "native", + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 135, + "start_line": 135 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=91:6 imports_exports=8:9 calls_definitions=44:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 70, + "column": 70, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "identity": "tools/check_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=91:6 imports_exports=8:9 calls_definitions=44:9" + } + }, + "origin": "native", + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 5602, + "column": 70, + "line": 135 + }, + "start": { + "byte": 5532, + "column": 0, + "line": 135 + } + }, + "start_line": 135 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "identity": "tools/check_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::<module>", + "description": "This checker intentionally enforces only repo-wide invariants that are already\ncanon in AGENTS.md and skill-build/SKILL.md. It reports softer section-shape\nrecommendations as warnings so historical skills can be normalized family by\nfamily without doctrinal churn.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Check baseline SKILL.md compliance for skill-lib.", + "text": "Check baseline SKILL.md compliance for skill-lib.\n\nThis checker intentionally enforces only repo-wide invariants that are already\ncanon in AGENTS.md and skill-build/SKILL.md. It reports softer section-shape\nrecommendations as warnings so historical skills can be normalized family by\nfamily without doctrinal churn.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 8, + "span": { + "end": { + "byte": 393, + "column": 3, + "line": 8 + }, + "start": { + "byte": 71, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "identity": "tools/check_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "identity": "tools/check_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "identity": "tools/check_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "identity": "tools/check_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "identity": "tools/check_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "identity": "tools/check_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "dataclasses:dataclass:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "dataclasses", + "name": "dataclass" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "identity": "tools/check_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "identity": "tools/check_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterable:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/module/tools%2Fcheck_skill_compliance.py", + "identity": "tools/check_skill_compliance.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/Finding/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "Finding", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::class:Finding", + "decorators": [ + "dataclass(frozen=True)" + ], + "kind": "class", + "name": "Finding", + "parent_identity": null, + "qualified_name": "Finding", + "signature": "class Finding" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 28, + "span": { + "end": { + "byte": 712, + "column": 16, + "line": 28 + }, + "start": { + "byte": 613, + "column": 0, + "line": 23 + } + }, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/Finding", + "identity": "Finding", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/check_skill/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "check_skill", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::function:check_skill", + "decorators": [], + "kind": "function", + "name": "check_skill", + "parent_identity": null, + "qualified_name": "check_skill", + "signature": "def check_skill(path: Path, indexed: dict[str, dict]) -> list[Finding]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 100, + "span": { + "end": { + "byte": 4109, + "column": 19, + "line": 100 + }, + "start": { + "byte": 1849, + "column": 0, + "line": 66 + } + }, + "start_line": 66 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/check_skill", + "identity": "check_skill", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/collect_findings/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "collect_findings", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::function:collect_findings", + "decorators": [], + "kind": "function", + "name": "collect_findings", + "parent_identity": null, + "qualified_name": "collect_findings", + "signature": "def collect_findings(root: Path=ROOT) -> list[Finding]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 109, + "span": { + "end": { + "byte": 4447, + "column": 19, + "line": 109 + }, + "start": { + "byte": 4112, + "column": 0, + "line": 103 + } + }, + "start_line": 103 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/collect_findings", + "identity": "collect_findings", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/frontmatter/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "frontmatter", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::function:frontmatter", + "decorators": [], + "kind": "function", + "name": "frontmatter", + "parent_identity": null, + "qualified_name": "frontmatter", + "signature": "def frontmatter(text: str) -> dict[str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 52, + "span": { + "end": { + "byte": 1404, + "column": 15, + "line": 52 + }, + "start": { + "byte": 1037, + "column": 0, + "line": 42 + } + }, + "start_line": 42 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/frontmatter", + "identity": "frontmatter", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/frontmatter_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "frontmatter_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::function:frontmatter_text", + "decorators": [], + "kind": "function", + "name": "frontmatter_text", + "parent_identity": null, + "qualified_name": "frontmatter_text", + "signature": "def frontmatter_text(text: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 57, + "span": { + "end": { + "byte": 1533, + "column": 47, + "line": 57 + }, + "start": { + "byte": 1407, + "column": 0, + "line": 55 + } + }, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/frontmatter_text", + "identity": "frontmatter_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/has_heading/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "has_heading", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::function:has_heading", + "decorators": [], + "kind": "function", + "name": "has_heading", + "parent_identity": null, + "qualified_name": "has_heading", + "signature": "def has_heading(text: str, *names: str) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 63, + "span": { + "end": { + "byte": 1846, + "column": 113, + "line": 63 + }, + "start": { + "byte": 1536, + "column": 0, + "line": 60 + } + }, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/has_heading", + "identity": "has_heading", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/load_index/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "load_index", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::function:load_index", + "decorators": [], + "kind": "function", + "name": "load_index", + "parent_identity": null, + "qualified_name": "load_index", + "signature": "def load_index(root: Path=ROOT) -> dict" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 35, + "span": { + "end": { + "byte": 904, + "column": 73, + "line": 35 + }, + "start": { + "byte": 788, + "column": 0, + "line": 34 + } + }, + "start_line": 34 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/load_index", + "identity": "load_index", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: Iterable[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 130, + "span": { + "end": { + "byte": 5481, + "column": 66, + "line": 130 + }, + "start": { + "byte": 4450, + "column": 0, + "line": 112 + } + }, + "start_line": 112 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/skill_paths/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "skill_paths", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_compliance.py::function:skill_paths", + "decorators": [], + "kind": "function", + "name": "skill_paths", + "parent_identity": null, + "qualified_name": "skill_paths", + "signature": "def skill_paths(root: Path=ROOT) -> list[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8753df69ea8a46e804270d3b9f8409fdb95f1dd4697609a16266b223de62336f", + "file": "tools/check_skill_compliance.py", + "location": { + "end_line": 39, + "span": { + "end": { + "byte": 1034, + "column": 77, + "line": 39 + }, + "start": { + "byte": 907, + "column": 0, + "line": 38 + } + }, + "start_line": 38 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_compliance.py#subject/symbol/skill_paths", + "identity": "skill_paths", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "85:15" + } + }, + "origin": "native", + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A230-230/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "85:15" + } + }, + "origin": "native", + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 230, + "start_line": 230 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "12:15" + } + }, + "origin": "native", + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A230-230/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "12:15" + } + }, + "origin": "native", + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 230, + "start_line": 230 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "173:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A230-230/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "173:5" + } + }, + "origin": "native", + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 230, + "start_line": 230 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=173:5 imports_exports=12:15 calls_definitions=85:15" + } + }, + "origin": "native", + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 74, + "column": 74, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=173:5 imports_exports=12:15 calls_definitions=85:15" + } + }, + "origin": "native", + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 230, + "span": { + "end": { + "byte": 8937, + "column": 74, + "line": 230 + }, + "start": { + "byte": 8863, + "column": 0, + "line": 230 + } + }, + "start_line": 230 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::<module>", + "description": "Checks that the canonical skill directories, skills.json, README.md,\nORG_DISTRIBUTION.md, AGENTS.md, CLAUDE.md, and generated llms.txt agree about\ninstalled skills and root LLM instructions. Pure stdlib. No network access.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Editorial drift checker for The-Interdependency/skill-lib.", + "text": "Editorial drift checker for The-Interdependency/skill-lib.\n\nChecks that the canonical skill directories, skills.json, README.md,\nORG_DISTRIBUTION.md, AGENTS.md, CLAUDE.md, and generated llms.txt agree about\ninstalled skills and root LLM instructions. Pure stdlib. No network access.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 7, + "span": { + "end": { + "byte": 364, + "column": 3, + "line": 7 + }, + "start": { + "byte": 75, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:List:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "List" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Mapping:11", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Mapping" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/12", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Sequence:12", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Sequence" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/13", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Set:13", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Set" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/14", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tools.build_codex_plugin_skills:canonical_metadata:14", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "tools.build_codex_plugin_skills", + "name": "canonical_metadata" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/15", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "build_codex_plugin_skills:canonical_metadata:15", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "build_codex_plugin_skills", + "name": "canonical_metadata" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 23, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "collections:Counter:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "collections", + "name": "Counter" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "dataclasses:dataclass:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "dataclasses", + "name": "dataclass" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Dict:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Dict" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/module/tools%2Fcheck_skill_lib_drift.py", + "identity": "tools/check_skill_lib_drift.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/Finding/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "Finding", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::class:Finding", + "decorators": [ + "dataclass" + ], + "kind": "class", + "name": "Finding", + "parent_identity": null, + "qualified_name": "Finding", + "signature": "class Finding" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 40, + "span": { + "end": { + "byte": 1122, + "column": 16, + "line": 40 + }, + "start": { + "byte": 1048, + "column": 0, + "line": 36 + } + }, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/Finding", + "identity": "Finding", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/check/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "check", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:check", + "decorators": [], + "kind": "function", + "name": "check", + "parent_identity": null, + "qualified_name": "check", + "signature": "def check() -> List[Finding]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 200, + "span": { + "end": { + "byte": 7706, + "column": 19, + "line": 200 + }, + "start": { + "byte": 4338, + "column": 0, + "line": 133 + } + }, + "start_line": 133 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/check", + "identity": "check", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/duplicate_entry_findings/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "duplicate_entry_findings", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:duplicate_entry_findings", + "decorators": [], + "kind": "function", + "name": "duplicate_entry_findings", + "parent_identity": null, + "qualified_name": "duplicate_entry_findings", + "signature": "def duplicate_entry_findings(index_entries: Sequence[Mapping[str, Any]], readme_name_list: Sequence[str], org_name_list: Sequence[str]) -> List[Finding]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 109, + "span": { + "end": { + "byte": 3524, + "column": 19, + "line": 109 + }, + "start": { + "byte": 2711, + "column": 0, + "line": 97 + } + }, + "start_line": 97 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/duplicate_entry_findings", + "identity": "duplicate_entry_findings", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/duplicate_names/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "duplicate_names", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:duplicate_names", + "decorators": [], + "kind": "function", + "name": "duplicate_names", + "parent_identity": null, + "qualified_name": "duplicate_names", + "signature": "def duplicate_names(names: Sequence[str]) -> List[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 78, + "span": { + "end": { + "byte": 2316, + "column": 78, + "line": 78 + }, + "start": { + "byte": 2182, + "column": 0, + "line": 77 + } + }, + "start_line": 77 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/duplicate_names", + "identity": "duplicate_names", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/has_mention/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "has_mention", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:has_mention", + "decorators": [], + "kind": "function", + "name": "has_mention", + "parent_identity": null, + "qualified_name": "has_mention", + "signature": "def has_mention(text: str, skill: str) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 113, + "span": { + "end": { + "byte": 3648, + "column": 73, + "line": 113 + }, + "start": { + "byte": 3527, + "column": 0, + "line": 112 + } + }, + "start_line": 112 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/has_mention", + "identity": "has_mention", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/llms_drift_finding/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:llms_drift_finding", + "metadata_kind": "comment", + "text": "pragma: no cover - defensive editorial check" + } + }, + "origin": "native", + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 120, + "span": { + "end": { + "byte": 3863, + "column": 76, + "line": 120 + }, + "start": { + "byte": 3817, + "column": 30, + "line": 120 + } + }, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/llms_drift_finding", + "identity": "llms_drift_finding", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/llms_drift_finding/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "llms_drift_finding", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:llms_drift_finding", + "decorators": [], + "kind": "function", + "name": "llms_drift_finding", + "parent_identity": null, + "qualified_name": "llms_drift_finding", + "signature": "def llms_drift_finding() -> Finding | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 130, + "span": { + "end": { + "byte": 4335, + "column": 15, + "line": 130 + }, + "start": { + "byte": 3651, + "column": 0, + "line": 116 + } + }, + "start_line": 116 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/llms_drift_finding", + "identity": "llms_drift_finding", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/llms_drift_finding/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "llms.build:collect:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "llms.build", + "name": "collect" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 119, + "start_line": 119 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/llms_drift_finding", + "identity": "llms_drift_finding", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/llms_drift_finding/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "llms.build:generate:1", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "llms.build", + "name": "generate" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 119, + "start_line": 119 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/llms_drift_finding", + "identity": "llms_drift_finding", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/load_index/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "load_index", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:load_index", + "decorators": [], + "kind": "function", + "name": "load_index", + "parent_identity": null, + "qualified_name": "load_index", + "signature": "def load_index(path: Path=SKILLS_JSON) -> Dict[str, Mapping[str, Any]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 74, + "span": { + "end": { + "byte": 2179, + "column": 18, + "line": 74 + }, + "start": { + "byte": 1904, + "column": 0, + "line": 68 + } + }, + "start_line": 68 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/load_index", + "identity": "load_index", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/load_index_entries/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "load_index_entries", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:load_index_entries", + "decorators": [], + "kind": "function", + "name": "load_index_entries", + "parent_identity": null, + "qualified_name": "load_index_entries", + "signature": "def load_index_entries(path: Path=SKILLS_JSON) -> List[Mapping[str, Any]]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 65, + "span": { + "end": { + "byte": 1901, + "column": 68, + "line": 65 + }, + "start": { + "byte": 1560, + "column": 0, + "line": 60 + } + }, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/load_index_entries", + "identity": "load_index_entries", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: list[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 225, + "span": { + "end": { + "byte": 8804, + "column": 39, + "line": 225 + }, + "start": { + "byte": 7709, + "column": 0, + "line": 203 + } + }, + "start_line": 203 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/names_in_org/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "names_in_org", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:names_in_org", + "decorators": [], + "kind": "function", + "name": "names_in_org", + "parent_identity": null, + "qualified_name": "names_in_org", + "signature": "def names_in_org(text: str) -> Set[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 94, + "span": { + "end": { + "byte": 2708, + "column": 39, + "line": 94 + }, + "start": { + "byte": 2628, + "column": 0, + "line": 93 + } + }, + "start_line": 93 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/names_in_org", + "identity": "names_in_org", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/names_in_org_list/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "names_in_org_list", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:names_in_org_list", + "decorators": [], + "kind": "function", + "name": "names_in_org_list", + "parent_identity": null, + "qualified_name": "names_in_org_list", + "signature": "def names_in_org_list(text: str) -> List[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 90, + "span": { + "end": { + "byte": 2625, + "column": 48, + "line": 90 + }, + "start": { + "byte": 2528, + "column": 0, + "line": 89 + } + }, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/names_in_org_list", + "identity": "names_in_org_list", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/names_in_readme/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "names_in_readme", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:names_in_readme", + "decorators": [], + "kind": "function", + "name": "names_in_readme", + "parent_identity": null, + "qualified_name": "names_in_readme", + "signature": "def names_in_readme(text: str) -> Set[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 86, + "span": { + "end": { + "byte": 2525, + "column": 42, + "line": 86 + }, + "start": { + "byte": 2439, + "column": 0, + "line": 85 + } + }, + "start_line": 85 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/names_in_readme", + "identity": "names_in_readme", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/names_in_readme_list/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "names_in_readme_list", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:names_in_readme_list", + "decorators": [], + "kind": "function", + "name": "names_in_readme_list", + "parent_identity": null, + "qualified_name": "names_in_readme_list", + "signature": "def names_in_readme_list(text: str) -> List[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 82, + "span": { + "end": { + "byte": 2436, + "column": 67, + "line": 82 + }, + "start": { + "byte": 2319, + "column": 0, + "line": 81 + } + }, + "start_line": 81 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/names_in_readme_list", + "identity": "names_in_readme_list", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/read/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:read", + "decorators": [], + "kind": "function", + "name": "read", + "parent_identity": null, + "qualified_name": "read", + "signature": "def read(path: Path) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 47, + "span": { + "end": { + "byte": 1258, + "column": 17, + "line": 47 + }, + "start": { + "byte": 1125, + "column": 0, + "line": 43 + } + }, + "start_line": 43 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/read", + "identity": "read", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/skill_dirs/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "skill_dirs", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/check_skill_lib_drift.py::function:skill_dirs", + "decorators": [], + "kind": "function", + "name": "skill_dirs", + "parent_identity": null, + "qualified_name": "skill_dirs", + "signature": "def skill_dirs(root: Path=ROOT) -> Set[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "fe030566d1e6756fa52567a4f1928cd10ecc25b23a4b7952870fb235d6b0003f", + "file": "tools/check_skill_lib_drift.py", + "location": { + "end_line": 57, + "span": { + "end": { + "byte": 1557, + "column": 14, + "line": 57 + }, + "start": { + "byte": 1261, + "column": 0, + "line": 50 + } + }, + "start_line": 50 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/check_skill_lib_drift.py#subject/symbol/skill_dirs", + "identity": "skill_dirs", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A2-2/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "534f315eb67c9657683868c37c8e348eb60f40d8bdf4fcc95c6ac27833fadce1", + "file": "tools/install_ai.sh", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A58-58/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "534f315eb67c9657683868c37c8e348eb60f40d8bdf4fcc95c6ac27833fadce1", + "file": "tools/install_ai.sh", + "location": { + "end_line": 58, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A2-2/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "534f315eb67c9657683868c37c8e348eb60f40d8bdf4fcc95c6ac27833fadce1", + "file": "tools/install_ai.sh", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A58-58/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "534f315eb67c9657683868c37c8e348eb60f40d8bdf4fcc95c6ac27833fadce1", + "file": "tools/install_ai.sh", + "location": { + "end_line": 58, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A2-2/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "534f315eb67c9657683868c37c8e348eb60f40d8bdf4fcc95c6ac27833fadce1", + "file": "tools/install_ai.sh", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A58-58/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "534f315eb67c9657683868c37c8e348eb60f40d8bdf4fcc95c6ac27833fadce1", + "file": "tools/install_ai.sh", + "location": { + "end_line": 58, + "start_line": 58 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/tools%2Finstall_ai.sh/fact/interpreter/lines%3A1-1/shebang", + "convention": { + "dialect": "sh", + "namespace": "posix.shebang", + "version": "source declaration v1" + }, + "extraction": { + "configuration_sha256": "64715d255639d911f2d3cd2803a93b14b7288f30528cb729d844c119cd1f8637", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "shell-static", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "interpreter", + "native": { + "id": "shebang", + "value": { + "shebang": "/usr/bin/env bash" + } + }, + "origin": "native", + "source": { + "content_sha256": "534f315eb67c9657683868c37c8e348eb60f40d8bdf4fcc95c6ac27833fadce1", + "file": "tools/install_ai.sh", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/install_ai.sh#subject/file/tools%2Finstall_ai.sh", + "identity": "tools/install_ai.sh", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A2-2/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "109:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A426-426/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "109:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 426, + "start_line": 426 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A2-2/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "10:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A426-426/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "10:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 426, + "start_line": 426 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A2-2/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "328:51" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A426-426/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "328:51" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 426, + "start_line": 426 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::<module>", + "metadata_kind": "shebang", + "text": "!/usr/bin/env python3" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 22, + "column": 22, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=328:51 imports_exports=10:12 calls_definitions=109:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 2, + "span": { + "end": { + "byte": 99, + "column": 76, + "line": 2 + }, + "start": { + "byte": 23, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: org_ratio_comparison_runner\n module_name: org_ratio_compare\n module_kind: instrument\n summary: collect org-wide scalar and vector repo metrics and append docs.report oddities.\n owner: Codex\n public_surface: collect_metrics, build_report, append_report, command line\n internal_surface: scan_repo, oddities, line_count\n auth_boundary: none\n storage_boundary: write\n network_boundary: none\n user_data_boundary: none\n admin_only: false\n tests: tests/test_org_reports.py\n rollout: manual runner under tools\n rollback: remove tool and README entry\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 46, + "span": { + "end": { + "byte": 1693, + "column": 26, + "line": 46 + }, + "start": { + "byte": 1054, + "column": 0, + "line": 30 + } + }, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CONTRACTS ===\nid: org_ratio_skips_vendored_skills\n given: a repo contains product source and .agents/skills source\n then: scalar/vector metrics exclude the vendored .agents tree\n class: evidence\n\nid: org_ratio_oddities_visible\n given: a repo has low ratio coverage or dirty state\n then: build_report lists a human-readable oddity for that repo\n class: evidence\n=== END CONTRACTS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 58, + "span": { + "end": { + "byte": 2108, + "column": 23, + "line": 58 + }, + "start": { + "byte": 1695, + "column": 0, + "line": 48 + } + }, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=328:51 imports_exports=10:12 calls_definitions=109:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 426, + "span": { + "end": { + "byte": 17163, + "column": 76, + "line": 426 + }, + "start": { + "byte": 17087, + "column": 0, + "line": 426 + } + }, + "start_line": 426 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::<module>", + "description": "Usage guidance:\n python3 tools/org_ratio_compare.py --root ..\n python3 tools/org_ratio_compare.py --root .. --out ../docs.report --append\n python3 tools/org_ratio_compare.py --root .. --json\n\nThe runner walks immediate child git checkouts under ``--root`` and reports\ncomposition metrics useful for deciding where to scan deeply next. It skips\nvendored agent skills, dependency folders, build outputs, and caches by default.\nLarge text files are counted by bytes but not fully line-counted beyond the\nconfigured byte ceiling; those become visible ``hmmm`` oddities rather than\nquietly consuming unbounded local resources.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Collect shallow repo scalars/vectors and append ``docs.report`` oddities.", + "text": "Collect shallow repo scalars/vectors and append ``docs.report`` oddities.\n\nUsage guidance:\n python3 tools/org_ratio_compare.py --root ..\n python3 tools/org_ratio_compare.py --root .. --out ../docs.report --append\n python3 tools/org_ratio_compare.py --root .. --json\n\nThe runner walks immediate child git checkouts under ``--root`` and reports\ncomposition metrics useful for deciding where to scan deeply next. It skips\nvendored agent skills, dependency folders, build outputs, and caches by default.\nLarge text files are counted by bytes but not fully line-counted beyond the\nconfigured byte ceiling; those become visible ``hmmm`` oddities rather than\nquietly consuming unbounded local resources.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 16, + "span": { + "end": { + "byte": 812, + "column": 3, + "line": 16 + }, + "start": { + "byte": 100, + "column": 0, + "line": 3 + } + }, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 27, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "statistics:median:11", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "statistics", + "name": "median" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 28, + "start_line": 28 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 23, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 24, + "start_line": 24 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "dataclasses:asdict:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "dataclasses", + "name": "asdict" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 25, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "dataclasses:dataclass:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "dataclasses", + "name": "dataclass" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 25, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "datetime:datetime:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "datetime", + "name": "datetime" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "datetime:timezone:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "datetime", + "name": "timezone" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/module/tools%2Forg_ratio_compare.py", + "identity": "tools/org_ratio_compare.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/RepoMetrics.doc_to_source/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoMetrics.doc_to_source", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::method:RepoMetrics.doc_to_source", + "decorators": [ + "property" + ], + "kind": "method", + "name": "doc_to_source", + "parent_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::class:RepoMetrics", + "qualified_name": "RepoMetrics.doc_to_source", + "signature": "def doc_to_source(self) -> float | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 130, + "span": { + "end": { + "byte": 3887, + "column": 75, + "line": 130 + }, + "start": { + "byte": 3690, + "column": 4, + "line": 126 + } + }, + "start_line": 126 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/RepoMetrics.doc_to_source", + "identity": "RepoMetrics.doc_to_source", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/RepoMetrics.ratio_coverage/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "RepoMetrics.ratio_coverage", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::method:RepoMetrics.ratio_coverage", + "decorators": [ + "property" + ], + "kind": "method", + "name": "ratio_coverage", + "parent_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::class:RepoMetrics", + "qualified_name": "RepoMetrics.ratio_coverage", + "signature": "def ratio_coverage(self) -> float | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 124, + "span": { + "end": { + "byte": 3684, + "column": 99, + "line": 124 + }, + "start": { + "byte": 3470, + "column": 4, + "line": 120 + } + }, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/RepoMetrics.ratio_coverage", + "identity": "RepoMetrics.ratio_coverage", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/RepoMetrics/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "RepoMetrics", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::class:RepoMetrics", + "decorators": [ + "dataclass" + ], + "kind": "class", + "name": "RepoMetrics", + "parent_identity": null, + "qualified_name": "RepoMetrics", + "signature": "class RepoMetrics" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 130, + "span": { + "end": { + "byte": 3887, + "column": 75, + "line": 130 + }, + "start": { + "byte": 2820, + "column": 0, + "line": 90 + } + }, + "start_line": 90 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/RepoMetrics", + "identity": "RepoMetrics", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/append_report/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "append_report", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:append_report", + "decorators": [], + "kind": "function", + "name": "append_report", + "parent_identity": null, + "qualified_name": "append_report", + "signature": "def append_report(out: Path, report: str) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 396, + "span": { + "end": { + "byte": 15791, + "column": 26, + "line": 396 + }, + "start": { + "byte": 15354, + "column": 0, + "line": 387 + } + }, + "start_line": 387 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/append_report", + "identity": "append_report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/append_report/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:append_report", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Append one report section without truncating existing content.", + "text": "Append one report section without truncating existing content." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 388, + "span": { + "end": { + "byte": 15477, + "column": 72, + "line": 388 + }, + "start": { + "byte": 15409, + "column": 4, + "line": 388 + } + }, + "start_line": 388 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/append_report", + "identity": "append_report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/build_report/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "build_report", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:build_report", + "decorators": [], + "kind": "function", + "name": "build_report", + "parent_identity": null, + "qualified_name": "build_report", + "signature": "def build_report(metrics: list[RepoMetrics], root: Path=DEFAULT_ROOT, generated_at: str | None=None) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 384, + "span": { + "end": { + "byte": 15351, + "column": 27, + "line": 384 + }, + "start": { + "byte": 11895, + "column": 0, + "line": 312 + } + }, + "start_line": 312 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/build_report", + "identity": "build_report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/build_report/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:build_report", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Build one markdown docs.report section without writing it.", + "text": "Build one markdown docs.report section without writing it." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 313, + "span": { + "end": { + "byte": 12076, + "column": 68, + "line": 313 + }, + "start": { + "byte": 12012, + "column": 4, + "line": 313 + } + }, + "start_line": 313 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/build_report", + "identity": "build_report", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/collect_metrics/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "collect_metrics", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:collect_metrics", + "decorators": [], + "kind": "function", + "name": "collect_metrics", + "parent_identity": null, + "qualified_name": "collect_metrics", + "signature": "def collect_metrics(root: Path=DEFAULT_ROOT, max_text_bytes: int=5000000) -> list[RepoMetrics]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 275, + "span": { + "end": { + "byte": 9745, + "column": 92, + "line": 275 + }, + "start": { + "byte": 9470, + "column": 0, + "line": 273 + } + }, + "start_line": 273 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/collect_metrics", + "identity": "collect_metrics", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/collect_metrics/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:collect_metrics", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Collect metrics for every immediate child git checkout under ``root``.", + "text": "Collect metrics for every immediate child git checkout under ``root``." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 274, + "span": { + "end": { + "byte": 9652, + "column": 80, + "line": 274 + }, + "start": { + "byte": 9576, + "column": 4, + "line": 274 + } + }, + "start_line": 274 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/collect_metrics", + "identity": "collect_metrics", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/count_dirty_entries/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "count_dirty_entries", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:count_dirty_entries", + "decorators": [], + "kind": "function", + "name": "count_dirty_entries", + "parent_identity": null, + "qualified_name": "count_dirty_entries", + "signature": "def count_dirty_entries(status: str) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 270, + "span": { + "end": { + "byte": 9467, + "column": 16, + "line": 270 + }, + "start": { + "byte": 8997, + "column": 0, + "line": 257 + } + }, + "start_line": 257 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/count_dirty_entries", + "identity": "count_dirty_entries", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/count_dirty_entries/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:count_dirty_entries", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Count dirty status entries while ignoring generated report files.", + "text": "Count dirty status entries while ignoring generated report files." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 258, + "span": { + "end": { + "byte": 9117, + "column": 75, + "line": 258 + }, + "start": { + "byte": 9046, + "column": 4, + "line": 258 + } + }, + "start_line": 258 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/count_dirty_entries", + "identity": "count_dirty_entries", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/discover_repos/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "discover_repos", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:discover_repos", + "decorators": [], + "kind": "function", + "name": "discover_repos", + "parent_identity": null, + "qualified_name": "discover_repos", + "signature": "def discover_repos(root: Path) -> list[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 154, + "span": { + "end": { + "byte": 4742, + "column": 60, + "line": 154 + }, + "start": { + "byte": 4435, + "column": 0, + "line": 150 + } + }, + "start_line": 150 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/discover_repos", + "identity": "discover_repos", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/discover_repos/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:discover_repos", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Discover immediate child git checkouts and worktrees under ``root``.", + "text": "Discover immediate child git checkouts and worktrees under ``root``." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 151, + "span": { + "end": { + "byte": 4559, + "column": 78, + "line": 151 + }, + "start": { + "byte": 4485, + "column": 4, + "line": 151 + } + }, + "start_line": 151 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/discover_repos", + "identity": "discover_repos", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/git_value/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "git_value", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:git_value", + "decorators": [], + "kind": "function", + "name": "git_value", + "parent_identity": null, + "qualified_name": "git_value", + "signature": "def git_value(repo: Path, *args: str) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 147, + "span": { + "end": { + "byte": 4432, + "column": 21, + "line": 147 + }, + "start": { + "byte": 4064, + "column": 0, + "line": 138 + } + }, + "start_line": 138 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/git_value", + "identity": "git_value", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/git_value/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:git_value", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Read one git value; return ``hmmm`` when unavailable.", + "text": "Read one git value; return ``hmmm`` when unavailable." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 139, + "span": { + "end": { + "byte": 4173, + "column": 63, + "line": 139 + }, + "start": { + "byte": 4114, + "column": 4, + "line": 139 + } + }, + "start_line": 139 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/git_value", + "identity": "git_value", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/line_count/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "line_count", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:line_count", + "decorators": [], + "kind": "function", + "name": "line_count", + "parent_identity": null, + "qualified_name": "line_count", + "signature": "def line_count(path: Path, max_text_bytes: int) -> tuple[int, bool]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 164, + "span": { + "end": { + "byte": 5111, + "column": 22, + "line": 164 + }, + "start": { + "byte": 4745, + "column": 0, + "line": 157 + } + }, + "start_line": 157 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/line_count", + "identity": "line_count", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/line_count/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:line_count", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Count lines for reasonably sized text files; report large-file skips.", + "text": "Count lines for reasonably sized text files; report large-file skips." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 158, + "span": { + "end": { + "byte": 4893, + "column": 79, + "line": 158 + }, + "start": { + "byte": 4818, + "column": 4, + "line": 158 + } + }, + "start_line": 158 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/line_count", + "identity": "line_count", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: list[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 421, + "span": { + "end": { + "byte": 17028, + "column": 12, + "line": 421 + }, + "start": { + "byte": 15794, + "column": 0, + "line": 399 + } + }, + "start_line": 399 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/now_utc/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "now_utc", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:now_utc", + "decorators": [], + "kind": "function", + "name": "now_utc", + "parent_identity": null, + "qualified_name": "now_utc", + "signature": "def now_utc() -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 4061, + "column": 90, + "line": 135 + }, + "start": { + "byte": 3890, + "column": 0, + "line": 133 + } + }, + "start_line": 133 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/now_utc", + "identity": "now_utc", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/now_utc/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:now_utc", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return an ISO UTC timestamp for report sections.", + "text": "Return an ISO UTC timestamp for report sections." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 134, + "span": { + "end": { + "byte": 3970, + "column": 58, + "line": 134 + }, + "start": { + "byte": 3916, + "column": 4, + "line": 134 + } + }, + "start_line": 134 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/now_utc", + "identity": "now_utc", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/oddities/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "oddities", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:oddities", + "decorators": [], + "kind": "function", + "name": "oddities", + "parent_identity": null, + "qualified_name": "oddities", + "signature": "def oddities(metrics: list[RepoMetrics]) -> list[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 309, + "span": { + "end": { + "byte": 11892, + "column": 14, + "line": 309 + }, + "start": { + "byte": 9748, + "column": 0, + "line": 278 + } + }, + "start_line": 278 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/oddities", + "identity": "oddities", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/oddities/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:oddities", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Generate visible oddities from scalar/vector comparisons.", + "text": "Generate visible oddities from scalar/vector comparisons." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 279, + "span": { + "end": { + "byte": 9870, + "column": 67, + "line": 279 + }, + "start": { + "byte": 9807, + "column": 4, + "line": 279 + } + }, + "start_line": 279 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/oddities", + "identity": "oddities", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/scan_repo/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "scan_repo", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:scan_repo", + "decorators": [], + "kind": "function", + "name": "scan_repo", + "parent_identity": null, + "qualified_name": "scan_repo", + "signature": "def scan_repo(repo: Path, max_text_bytes: int=5000000) -> RepoMetrics" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 254, + "span": { + "end": { + "byte": 8994, + "column": 5, + "line": 254 + }, + "start": { + "byte": 5114, + "column": 0, + "line": 167 + } + }, + "start_line": 167 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/scan_repo", + "identity": "scan_repo", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/scan_repo/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/org_ratio_compare.py::function:scan_repo", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Collect shallow scalar/vector metrics for one repo checkout.", + "text": "Collect shallow scalar/vector metrics for one repo checkout." + } + }, + "origin": "native", + "source": { + "content_sha256": "e3dfd9cc60d6cb0cc92c6d2805890581d0d86f55431fd0afe206509919187568", + "file": "tools/org_ratio_compare.py", + "location": { + "end_line": 168, + "span": { + "end": { + "byte": 5259, + "column": 70, + "line": 168 + }, + "start": { + "byte": 5193, + "column": 4, + "line": 168 + } + }, + "start_line": 168 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/org_ratio_compare.py#subject/symbol/scan_repo", + "identity": "scan_repo", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "96:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A249-249/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "96:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 249, + "start_line": 249 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "9:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A249-249/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "9:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 249, + "start_line": 249 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "197:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A249-249/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "197:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 249, + "start_line": 249 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=197:14 imports_exports=9:11 calls_definitions=96:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 74, + "column": 74, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_scope", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::<module>", + "metadata_kind": "comment", + "text": "Skills may link to shared docs under `doctrine/` (e.g. `../doctrine/msdmd-checks.md`);\nthose must be carried alongside the skills or the vendored links go dead." + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 26, + "span": { + "end": { + "byte": 1019, + "column": 75, + "line": 26 + }, + "start": { + "byte": 855, + "column": 0, + "line": 25 + } + }, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=197:14 imports_exports=9:11 calls_definitions=96:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 249, + "span": { + "end": { + "byte": 10143, + "column": 74, + "line": 249 + }, + "start": { + "byte": 10069, + "column": 0, + "line": 249 + } + }, + "start_line": 249 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::<module>", + "description": "This script is intentionally local-file based. It does not push, commit, open\nPRs, or contact GitHub. Run it from a checked-out skill-lib repo and point it at\na checked-out target repo. Repo-local additions are preserved. Files retired\nfrom canonical are removed only when the target's cited prior source commit\nproves they are unchanged canonical files. Dry-run is the default.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Synchronize canonical skill-lib skills into a target repo working tree.", + "text": "Synchronize canonical skill-lib skills into a target repo working tree.\n\nThis script is intentionally local-file based. It does not push, commit, open\nPRs, or contact GitHub. Run it from a checked-out skill-lib repo and point it at\na checked-out target repo. Repo-local additions are preserved. Files retired\nfrom canonical are removed only when the target's cited prior source commit\nproves they are unchanged canonical files. Dry-run is the default.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 9, + "span": { + "end": { + "byte": 533, + "column": 3, + "line": 9 + }, + "start": { + "byte": 75, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Mapping:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Mapping" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Sequence:11", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Sequence" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "re:re:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "re", + "name": "re" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "shutil:shutil:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "shutil", + "name": "shutil" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:6", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Iterable:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Iterable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:List:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "List" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/module/tools%2Fpropagate_skills.py", + "identity": "tools/propagate_skills.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/current_sha/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "current_sha", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:current_sha", + "decorators": [], + "kind": "function", + "name": "current_sha", + "parent_identity": null, + "qualified_name": "current_sha", + "signature": "def current_sha() -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 58, + "span": { + "end": { + "byte": 2078, + "column": 43, + "line": 58 + }, + "start": { + "byte": 1799, + "column": 0, + "line": 50 + } + }, + "start_line": 50 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/current_sha", + "identity": "current_sha", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/load_index/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "load_index", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:load_index", + "decorators": [], + "kind": "function", + "name": "load_index", + "parent_identity": null, + "qualified_name": "load_index", + "signature": "def load_index() -> Mapping[str, object]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 34, + "span": { + "end": { + "byte": 1446, + "column": 62, + "line": 34 + }, + "start": { + "byte": 1342, + "column": 0, + "line": 33 + } + }, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/load_index", + "identity": "load_index", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/load_skill_names/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "load_skill_names", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:load_skill_names", + "decorators": [], + "kind": "function", + "name": "load_skill_names", + "parent_identity": null, + "qualified_name": "load_skill_names", + "signature": "def load_skill_names() -> List[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 39, + "span": { + "end": { + "byte": 1577, + "column": 67, + "line": 39 + }, + "start": { + "byte": 1449, + "column": 0, + "line": 37 + } + }, + "start_line": 37 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/load_skill_names", + "identity": "load_skill_names", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/load_superseded_names/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "load_superseded_names", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:load_superseded_names", + "decorators": [], + "kind": "function", + "name": "load_superseded_names", + "parent_identity": null, + "qualified_name": "load_superseded_names", + "signature": "def load_superseded_names() -> List[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 47, + "span": { + "end": { + "byte": 1796, + "column": 5, + "line": 47 + }, + "start": { + "byte": 1580, + "column": 0, + "line": 42 + } + }, + "start_line": 42 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/load_superseded_names", + "identity": "load_superseded_names", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/main/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:main", + "metadata_kind": "comment", + "text": "Carry any shared doctrine docs the propagated skills link to." + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 203, + "span": { + "end": { + "byte": 8414, + "column": 67, + "line": 203 + }, + "start": { + "byte": 8351, + "column": 4, + "line": 203 + } + }, + "start_line": 203 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main(argv: Sequence[str] | None=None) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 244, + "span": { + "end": { + "byte": 10010, + "column": 12, + "line": 244 + }, + "start": { + "byte": 6724, + "column": 0, + "line": 169 + } + }, + "start_line": 169 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/previous_canonical_blob/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "previous_canonical_blob", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:previous_canonical_blob", + "decorators": [], + "kind": "function", + "name": "previous_canonical_blob", + "parent_identity": null, + "qualified_name": "previous_canonical_blob", + "signature": "def previous_canonical_blob(sha: str, skill_name: str, relative_path: Path) -> bytes | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 88, + "span": { + "end": { + "byte": 3166, + "column": 60, + "line": 88 + }, + "start": { + "byte": 2798, + "column": 0, + "line": 81 + } + }, + "start_line": 81 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/previous_canonical_blob", + "identity": "previous_canonical_blob", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/previous_skill_source_sha/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "previous_skill_source_sha", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:previous_skill_source_sha", + "decorators": [], + "kind": "function", + "name": "previous_skill_source_sha", + "parent_identity": null, + "qualified_name": "previous_skill_source_sha", + "signature": "def previous_skill_source_sha(target_install_root: Path, skill_name: str) -> str | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 78, + "span": { + "end": { + "byte": 2795, + "column": 15, + "line": 78 + }, + "start": { + "byte": 2359, + "column": 0, + "line": 69 + } + }, + "start_line": 69 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/previous_skill_source_sha", + "identity": "previous_skill_source_sha", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/previous_skill_source_sha/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:previous_skill_source_sha", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return a skill-local prior source recorded by an earlier partial refresh.", + "text": "Return a skill-local prior source recorded by an earlier partial refresh." + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 70, + "span": { + "end": { + "byte": 2531, + "column": 83, + "line": 70 + }, + "start": { + "byte": 2452, + "column": 4, + "line": 70 + } + }, + "start_line": 70 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/previous_skill_source_sha", + "identity": "previous_skill_source_sha", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/previous_source_sha/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "previous_source_sha", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:previous_source_sha", + "decorators": [], + "kind": "function", + "name": "previous_source_sha", + "parent_identity": null, + "qualified_name": "previous_source_sha", + "signature": "def previous_source_sha(target_install_root: Path) -> str | None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 66, + "span": { + "end": { + "byte": 2356, + "column": 44, + "line": 66 + }, + "start": { + "byte": 2081, + "column": 0, + "line": 61 + } + }, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/previous_source_sha", + "identity": "previous_source_sha", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/referenced_doctrine/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "referenced_doctrine", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:referenced_doctrine", + "decorators": [], + "kind": "function", + "name": "referenced_doctrine", + "parent_identity": null, + "qualified_name": "referenced_doctrine", + "signature": "def referenced_doctrine(skill_srcs: Iterable[Path]) -> List[str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 124, + "span": { + "end": { + "byte": 4678, + "column": 77, + "line": 124 + }, + "start": { + "byte": 4163, + "column": 0, + "line": 116 + } + }, + "start_line": 116 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/referenced_doctrine", + "identity": "referenced_doctrine", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/referenced_doctrine/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:referenced_doctrine", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Shared `doctrine/<file>` docs the given skill directories link to.", + "text": "Shared `doctrine/<file>` docs the given skill directories link to." + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 117, + "span": { + "end": { + "byte": 4305, + "column": 76, + "line": 117 + }, + "start": { + "byte": 4233, + "column": 4, + "line": 117 + } + }, + "start_line": 117 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/referenced_doctrine", + "identity": "referenced_doctrine", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/sync_tree/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "sync_tree", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:sync_tree", + "decorators": [], + "kind": "function", + "name": "sync_tree", + "parent_identity": null, + "qualified_name": "sync_tree", + "signature": "def sync_tree(src: Path, dst: Path, prior_sha: str | None) -> List[Path]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 113, + "span": { + "end": { + "byte": 4160, + "column": 18, + "line": 113 + }, + "start": { + "byte": 3169, + "column": 0, + "line": 91 + } + }, + "start_line": 91 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/sync_tree", + "identity": "sync_tree", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/sync_tree/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:sync_tree", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Update canonical files without deleting proven repo-local additions.", + "text": "Update canonical files without deleting proven repo-local additions." + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 92, + "span": { + "end": { + "byte": 3321, + "column": 78, + "line": 92 + }, + "start": { + "byte": 3247, + "column": 4, + "line": 92 + } + }, + "start_line": 92 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/sync_tree", + "identity": "sync_tree", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/write_readme/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:write_readme", + "metadata_kind": "comment", + "text": "Preserve owner-written descriptions for installed but unrefreshed skills." + } + }, + "origin": "native", + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 131, + "span": { + "end": { + "byte": 5058, + "column": 79, + "line": 131 + }, + "start": { + "byte": 4983, + "column": 4, + "line": 131 + } + }, + "start_line": 131 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/write_readme", + "identity": "write_readme", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/write_readme/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "write_readme", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/propagate_skills.py::function:write_readme", + "decorators": [], + "kind": "function", + "name": "write_readme", + "parent_identity": null, + "qualified_name": "write_readme", + "signature": "def write_readme(target_install_root: Path, sha: str, skills: Sequence[str]) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ddc5e911193cd31207ef398954a2076d5ecec423fdcbc6f3d43616312e55acf4", + "file": "tools/propagate_skills.py", + "location": { + "end_line": 166, + "span": { + "end": { + "byte": 6721, + "column": 86, + "line": 166 + }, + "start": { + "byte": 4681, + "column": 0, + "line": 127 + } + }, + "start_line": 127 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/propagate_skills.py#subject/symbol/write_readme", + "identity": "write_readme", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A2-2/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "56:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A198-198/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "56:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 198, + "start_line": 198 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A2-2/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "8:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A198-198/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "8:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 198, + "start_line": 198 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A2-2/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "148:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A198-198/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "148:11" + } + }, + "origin": "native", + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 198, + "start_line": 198 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::<module>", + "metadata_kind": "shebang", + "text": "!/usr/bin/env python3" + } + }, + "origin": "native", + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 22, + "column": 22, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=148:11 imports_exports=8:12 calls_definitions=56:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 2, + "span": { + "end": { + "byte": 97, + "column": 74, + "line": 2 + }, + "start": { + "byte": 23, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=148:11 imports_exports=8:12 calls_definitions=56:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 198, + "span": { + "end": { + "byte": 6781, + "column": 74, + "line": 198 + }, + "start": { + "byte": 6707, + "column": 0, + "line": 198 + } + }, + "start_line": 198 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::<module>", + "description": "Usage guidance:\n python tools/skill_usage.py record canon --outcome success\n python tools/skill_usage.py record canon --outcome failed --critical\n python tools/skill_usage.py resolve-critical canon\n python tools/skill_usage.py status\n\nInstalled plugins should pass ``--state \"$PLUGIN_DATA/usage.json\"``. Without\n``--state``, data is stored in ``.skill-lib/usage.json`` under the current\nworking directory. Writes are atomic. The file contains no prompt content.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Record skill-lib exposure and derive evidence-qualified maturity.", + "text": "Record skill-lib exposure and derive evidence-qualified maturity.\n\nUsage guidance:\n python tools/skill_usage.py record canon --outcome success\n python tools/skill_usage.py record canon --outcome failed --critical\n python tools/skill_usage.py resolve-critical canon\n python tools/skill_usage.py status\n\nInstalled plugins should pass ``--state \"$PLUGIN_DATA/usage.json\"``. Without\n``--state``, data is stored in ``.skill-lib/usage.json`` under the current\nworking directory. Writes are atomic. The file contains no prompt content.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 14, + "span": { + "end": { + "byte": 645, + "column": 3, + "line": 14 + }, + "start": { + "byte": 98, + "column": 0, + "line": 3 + } + }, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "argparse:argparse:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "argparse", + "name": "argparse" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "datetime:datetime:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "datetime", + "name": "datetime" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "datetime:timezone:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "datetime", + "name": "timezone" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 23, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 24, + "start_line": 24 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/module/tools%2Fskill_usage.py", + "identity": "tools/skill_usage.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/atomic_write/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "atomic_write", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:atomic_write", + "decorators": [], + "kind": "function", + "name": "atomic_write", + "parent_identity": null, + "qualified_name": "atomic_write", + "signature": "def atomic_write(path: Path, data: dict[str, Any]) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 68, + "span": { + "end": { + "byte": 2152, + "column": 32, + "line": 68 + }, + "start": { + "byte": 1578, + "column": 0, + "line": 54 + } + }, + "start_line": 54 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/atomic_write", + "identity": "atomic_write", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/effective_designation/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "effective_designation", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:effective_designation", + "decorators": [], + "kind": "function", + "name": "effective_designation", + "parent_identity": null, + "qualified_name": "effective_designation", + "signature": "def effective_designation(record: dict[str, Any]) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 104, + "span": { + "end": { + "byte": 3394, + "column": 55, + "line": 104 + }, + "start": { + "byte": 2566, + "column": 0, + "line": 88 + } + }, + "start_line": 88 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/effective_designation", + "identity": "effective_designation", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/empty_state/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "empty_state", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:empty_state", + "decorators": [], + "kind": "function", + "name": "empty_state", + "parent_identity": null, + "qualified_name": "empty_state", + "signature": "def empty_state() -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 42, + "span": { + "end": { + "byte": 1248, + "column": 46, + "line": 42 + }, + "start": { + "byte": 1165, + "column": 0, + "line": 41 + } + }, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/empty_state", + "identity": "empty_state", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/load_state/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "load_state", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:load_state", + "decorators": [], + "kind": "function", + "name": "load_state", + "parent_identity": null, + "qualified_name": "load_state", + "signature": "def load_state(path: Path) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 51, + "span": { + "end": { + "byte": 1575, + "column": 15, + "line": 51 + }, + "start": { + "byte": 1251, + "column": 0, + "line": 45 + } + }, + "start_line": 45 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/load_state", + "identity": "load_state", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main() -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 193, + "span": { + "end": { + "byte": 6648, + "column": 12, + "line": 193 + }, + "start": { + "byte": 5931, + "column": 0, + "line": 174 + } + }, + "start_line": 174 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/new_record/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "new_record", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:new_record", + "decorators": [], + "kind": "function", + "name": "new_record", + "parent_identity": null, + "qualified_name": "new_record", + "signature": "def new_record() -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 77, + "span": { + "end": { + "byte": 2361, + "column": 5, + "line": 77 + }, + "start": { + "byte": 2155, + "column": 0, + "line": 71 + } + }, + "start_line": 71 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/new_record", + "identity": "new_record", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/nominal_designation/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "nominal_designation", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:nominal_designation", + "decorators": [], + "kind": "function", + "name": "nominal_designation", + "parent_identity": null, + "qualified_name": "nominal_designation", + "signature": "def nominal_designation(use_count: int) -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 85, + "span": { + "end": { + "byte": 2563, + "column": 17, + "line": 85 + }, + "start": { + "byte": 2364, + "column": 0, + "line": 80 + } + }, + "start_line": 80 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/nominal_designation", + "identity": "nominal_designation", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/now_utc/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "now_utc", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:now_utc", + "decorators": [], + "kind": "function", + "name": "now_utc", + "parent_identity": null, + "qualified_name": "now_utc", + "signature": "def now_utc() -> str" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 38, + "span": { + "end": { + "byte": 1162, + "column": 72, + "line": 38 + }, + "start": { + "byte": 1068, + "column": 0, + "line": 37 + } + }, + "start_line": 37 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/now_utc", + "identity": "now_utc", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/parser/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "parser", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:parser", + "decorators": [], + "kind": "function", + "name": "parser", + "parent_identity": null, + "qualified_name": "parser", + "signature": "def parser() -> argparse.ArgumentParser" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 171, + "span": { + "end": { + "byte": 5928, + "column": 17, + "line": 171 + }, + "start": { + "byte": 4753, + "column": 0, + "line": 145 + } + }, + "start_line": 145 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/parser", + "identity": "parser", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/record_use/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "record_use", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:record_use", + "decorators": [], + "kind": "function", + "name": "record_use", + "parent_identity": null, + "qualified_name": "record_use", + "signature": "def record_use(state: dict[str, Any], name: str, outcome: str, critical: bool) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 4476, + "column": 34, + "line": 135 + }, + "start": { + "byte": 4107, + "column": 0, + "line": 126 + } + }, + "start_line": 126 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/record_use", + "identity": "record_use", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/resolve_critical/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "resolve_critical", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:resolve_critical", + "decorators": [], + "kind": "function", + "name": "resolve_critical", + "parent_identity": null, + "qualified_name": "resolve_critical", + "signature": "def resolve_critical(state: dict[str, Any], name: str) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 142, + "span": { + "end": { + "byte": 4750, + "column": 34, + "line": 142 + }, + "start": { + "byte": 4479, + "column": 0, + "line": 138 + } + }, + "start_line": 138 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/resolve_critical", + "identity": "resolve_critical", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/summarize/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "summarize", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:tools/skill_usage.py::function:summarize", + "decorators": [], + "kind": "function", + "name": "summarize", + "parent_identity": null, + "qualified_name": "summarize", + "signature": "def summarize(name: str, record: dict[str, Any]) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "8ba7d131f1e536d0e6a565819680ecd07adde6b06642c392796c140ac3719fbd", + "file": "tools/skill_usage.py", + "location": { + "end_line": 123, + "span": { + "end": { + "byte": 4104, + "column": 5, + "line": 123 + }, + "start": { + "byte": 3397, + "column": 0, + "line": 107 + } + }, + "start_line": 107 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/tools/skill_usage.py#subject/symbol/summarize", + "identity": "summarize", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/typed-meta-frontend/SKILL.md#subject/document/typed-meta-frontend%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "TypeScript frontend generation from backend-owned module metadata and living specs. Load this when building, reviewing, or refactoring a self-building UI that reads backend metadata, exposes every editable field per module, renders each module's living spec, generates TypeScript types/forms/routes from metadata, or keeps admin/editor frontends synchronized with msdmd-style source declarations.", + "name": "typed-meta-frontend" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "047ec94675d6e44da94ed325c62216d0c45d78a0485cdcdd13049dd23500cc29", + "file": "typed-meta-frontend/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/typed-meta-frontend/SKILL.md#subject/document/typed-meta-frontend%2FSKILL.md", + "identity": "typed-meta-frontend/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ucns-option-selection/SKILL.md#subject/document/ucns-option-selection%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Fail-closed rubric for comparing, retaining, rejecting, deprecating, and selecting UCNS options within an explicit scope. Load this when an agent asks which UCNS candidate should win, whether evidence authorizes selection, how an option moves from registered or implemented to selected, how to compare competing gonol constructors, carriers, geometries, policies, projections, or measurement candidates, or how to issue a scoped UCNS decision receipt. Do not load merely to register options, execute one already-selected option, or choose ordinary UI preferences. Never select universal UCNS canon by score, familiarity, implementation order, or EDCM-local evidence.", + "name": "ucns-option-selection" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "1572833b56ff8f1af41fb6f01bb3e91c300cf825a326900d272fcb4ba26bd3cb", + "file": "ucns-option-selection/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/ucns-option-selection/SKILL.md#subject/document/ucns-option-selection%2FSKILL.md", + "identity": "ucns-option-selection/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/validate-data/SKILL.md#subject/document/validate-data%2FSKILL.md/fact/frontmatter/lines%3A1-5", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "argument-hint": "<analysis to review>", + "description": "QA an analysis before sharing -- methodology, accuracy, and bias checks. Use this when reviewing an analysis before a stakeholder presentation, spot-checking calculations and aggregation logic, verifying a SQL query's results look right, or assessing whether conclusions are actually supported by the data.", + "name": "validate-data" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "256a1a65b55e66e6f3e05ee4547f69c7c3443b9ddc1d40100f132660c7af108b", + "file": "validate-data/SKILL.md", + "location": { + "end_line": 5, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/validate-data/SKILL.md#subject/document/validate-data%2FSKILL.md", + "identity": "validate-data/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/visitor-intro/SKILL.md#subject/document/visitor-intro%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Onboarding tour for visitors arriving at any The-Interdependency repo. Load this when an unfamiliar user asks \"what is this?\", \"what is The Interdependency?\", \"how do these repos fit together?\", \"where do I start?\", or otherwise signals they are new to the org. Gives the agent a consistent, repo-aware way to orient a newcomer without inventing facts.", + "name": "visitor-intro" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "cb80912a7e956a888f6a7ee074cbdc61709962f39be1bd2db44066929b7657c3", + "file": "visitor-intro/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/visitor-intro/SKILL.md#subject/document/visitor-intro%2FSKILL.md", + "identity": "visitor-intro/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/SKILL.md#subject/document/vm-mcp%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Private VM control-plane skill for giving an AI/MCP client SSH-like access to a Linux or Google Compute Engine VM without handing the client an SSH private key. Load this when a user asks to connect ChatGPT, an OpenAI client, Codex, Claude, or another MCP host to a VM; expose bounded shell/file tools on a private VM; replace repeated human SSH with an auditable MCP control plane; install or audit the shipped vm-mcp runtime; or add narrowly scoped administrative actions above the workspace shell. Do not load for ordinary human-only SSH setup with no MCP/agent access.", + "name": "vm-mcp" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "7b6d81cbefe4aaf62c14afd942e5399de34c84c53838375af5271f04a4525c64", + "file": "vm-mcp/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/SKILL.md#subject/document/vm-mcp%2FSKILL.md", + "identity": "vm-mcp/SKILL.md", + "scope": "document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "95:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A309-309/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "95:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 309, + "start_line": 309 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "16:3" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A309-309/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "16:3" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 309, + "start_line": 309 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "222:57" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A309-309/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "222:57" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 309, + "start_line": 309 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=222:57 imports_exports=16:3 calls_definitions=95:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 74, + "column": 74, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: vm_mcp_personal_console_broker\n module_name: vm_mcp_personal_console_broker\n module_kind: service\n summary: root-side Unix-socket broker for explicit non-root user_exec and root admin_exec in single-owner personal-console deployments\n owner: skill-lib vm-mcp maintainers\n public_surface: execute_request, serve\n internal_surface: peer credential verification, privilege drop, bounded process execution\n auth_boundary: admin\n storage_boundary: write\n network_boundary: local\n user_data_boundary: read_write\n admin_only: true\n tests: vm-mcp/tests/test_admin_broker.py\n rollout: vm-mcp-admin.service only when VM_MCP_PROFILE=personal-console\n rollback: stop and disable vm-mcp-admin.service; return vm-mcp to read-only or workspace profile\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 45, + "span": { + "end": { + "byte": 1601, + "column": 26, + "line": 45 + }, + "start": { + "byte": 767, + "column": 0, + "line": 29 + } + }, + "start_line": 29 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== BOUNDARIES ===\nid: vm_mcp_admin_broker_root_boundary\n summary: root-owned local broker receives only verified vmmcp Unix-socket requests and may execute arbitrary host commands in personal-console mode\n auth_boundary: admin\n storage_boundary: write\n network_boundary: local\n user_data_boundary: read_write\n admin_only: true\n side_effects: process, filesystem, service, database, network\n owner: skill-lib vm-mcp maintainers\n=== END BOUNDARIES ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 57, + "span": { + "end": { + "byte": 2083, + "column": 24, + "line": 57 + }, + "start": { + "byte": 1603, + "column": 0, + "line": 47 + } + }, + "start_line": 47 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CONTRACTS ===\nid: vm_mcp_admin_broker_peer_verified\n given: a process connects to the root broker Unix socket\n then: SO_PEERCRED must identify the configured vmmcp service user or the request is rejected\n class: security\n\nid: vm_mcp_user_exec_non_root\n given: personal-console user_exec requests a local user\n then: root is rejected and the child process drops uid/gid/groups to the requested non-root account before exec\n class: security\n\nid: vm_mcp_admin_exec_explicit_root\n given: personal-console admin_exec requests a command\n then: the broker executes it as uid 0 and reports root mode explicitly in the result\n class: authority\n\nid: vm_mcp_broker_execution_bounded\n given: a brokered command times out, emits excessive output, or leaves descendants running\n then: the process group is killed, output is capped, and terminal evidence is returned\n class: safety\n=== END CONTRACTS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 79, + "span": { + "end": { + "byte": 3028, + "column": 23, + "line": 79 + }, + "start": { + "byte": 2085, + "column": 0, + "line": 59 + } + }, + "start_line": 59 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/comment/4", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=222:57 imports_exports=16:3 calls_definitions=95:10" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 309, + "span": { + "end": { + "byte": 11771, + "column": 74, + "line": 309 + }, + "start": { + "byte": 11697, + "column": 0, + "line": 309 + } + }, + "start_line": 309 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::<module>", + "description": "Usage guidance:\n- Run only as the root-owned ``vm-mcp-admin.service``.\n- Accept requests only from the configured ``vmmcp`` Unix account.\n- ``user`` mode drops to the requested non-root account before execution.\n- ``admin`` mode remains root and is intentionally equivalent to broad host\n administration; keep the MCP transport private and single-owner.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Root-side Unix-socket execution broker for vm-mcp personal-console mode.", + "text": "Root-side Unix-socket execution broker for vm-mcp personal-console mode.\n\nUsage guidance:\n- Run only as the root-owned ``vm-mcp-admin.service``.\n- Accept requests only from the configured ``vmmcp`` Unix account.\n- ``user`` mode drops to the requested non-root account before execution.\n- ``admin`` mode remains root and is intentionally equivalent to broad host\n administration; keep the MCP transport private and single-owner.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 10, + "span": { + "end": { + "byte": 510, + "column": 3, + "line": 10 + }, + "start": { + "byte": 75, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "grp:grp:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "grp", + "name": "grp" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "struct:struct:10", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "struct", + "name": "struct" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "sys:sys:11", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "sys", + "name": "sys" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 23, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/12", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "time:time:12", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "time", + "name": "time" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 24, + "start_line": 24 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/13", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "uuid:uuid:13", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "uuid", + "name": "uuid" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 25, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/14", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:14", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/15", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:15", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 27, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "hashlib:hashlib:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "hashlib", + "name": "hashlib" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pwd:pwd:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "pwd", + "name": "pwd" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "selectors:selectors:6", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "selectors", + "name": "selectors" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "signal:signal:7", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "signal", + "name": "signal" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "socket:socket:8", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "socket", + "name": "socket" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:9", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/module/vm-mcp%2Fadmin_broker.py", + "identity": "vm-mcp/admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_account_for_request/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_account_for_request", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::function:_account_for_request", + "decorators": [], + "kind": "function", + "name": "_account_for_request", + "parent_identity": null, + "qualified_name": "_account_for_request", + "signature": "def _account_for_request(mode: str, user: str | None) -> pwd.struct_passwd" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 181, + "span": { + "end": { + "byte": 6782, + "column": 18, + "line": 181 + }, + "start": { + "byte": 6316, + "column": 0, + "line": 171 + } + }, + "start_line": 171 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_account_for_request", + "identity": "_account_for_request", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_communicate_bounded/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_communicate_bounded", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::function:_communicate_bounded", + "decorators": [], + "kind": "function", + "name": "_communicate_bounded", + "parent_identity": null, + "qualified_name": "_communicate_bounded", + "signature": "def _communicate_bounded(process: subprocess.Popen[bytes], *, timeout: float, limit: int) -> tuple[bytes, bytes, bool, bool, bool]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 168, + "span": { + "end": { + "byte": 6313, + "column": 5, + "line": 168 + }, + "start": { + "byte": 3993, + "column": 0, + "line": 115 + } + }, + "start_line": 115 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_communicate_bounded", + "identity": "_communicate_bounded", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_drop_privileges/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_drop_privileges", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::function:_drop_privileges", + "decorators": [], + "kind": "function", + "name": "_drop_privileges", + "parent_identity": null, + "qualified_name": "_drop_privileges", + "signature": "def _drop_privileges(account: pwd.struct_passwd) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 105, + "span": { + "end": { + "byte": 3829, + "column": 29, + "line": 105 + }, + "start": { + "byte": 3661, + "column": 0, + "line": 102 + } + }, + "start_line": 102 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_drop_privileges", + "identity": "_drop_privileges", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_kill_group/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_kill_group", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::function:_kill_group", + "decorators": [], + "kind": "function", + "name": "_kill_group", + "parent_identity": null, + "qualified_name": "_kill_group", + "signature": "def _kill_group(process: subprocess.Popen[bytes]) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 112, + "span": { + "end": { + "byte": 3990, + "column": 12, + "line": 112 + }, + "start": { + "byte": 3832, + "column": 0, + "line": 108 + } + }, + "start_line": 108 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_kill_group", + "identity": "_kill_group", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_peer_uid/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_peer_uid", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::function:_peer_uid", + "decorators": [], + "kind": "function", + "name": "_peer_uid", + "parent_identity": null, + "qualified_name": "_peer_uid", + "signature": "def _peer_uid(connection: socket.socket) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 251, + "span": { + "end": { + "byte": 9584, + "column": 14, + "line": 251 + }, + "start": { + "byte": 9283, + "column": 0, + "line": 246 + } + }, + "start_line": 246 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_peer_uid", + "identity": "_peer_uid", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_recv_request/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_recv_request", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::function:_recv_request", + "decorators": [], + "kind": "function", + "name": "_recv_request", + "parent_identity": null, + "qualified_name": "_recv_request", + "signature": "def _recv_request(connection: socket.socket) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 269, + "span": { + "end": { + "byte": 10143, + "column": 16, + "line": 269 + }, + "start": { + "byte": 9587, + "column": 0, + "line": 254 + } + }, + "start_line": 254 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_recv_request", + "identity": "_recv_request", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_safe_env/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_safe_env", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::function:_safe_env", + "decorators": [], + "kind": "function", + "name": "_safe_env", + "parent_identity": null, + "qualified_name": "_safe_env", + "signature": "def _safe_env(account: pwd.struct_passwd) -> dict[str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 99, + "span": { + "end": { + "byte": 3658, + "column": 5, + "line": 99 + }, + "start": { + "byte": 3221, + "column": 0, + "line": 89 + } + }, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/_safe_env", + "identity": "_safe_env", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/execute_request/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "execute_request", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::function:execute_request", + "decorators": [], + "kind": "function", + "name": "execute_request", + "parent_identity": null, + "qualified_name": "execute_request", + "signature": "def execute_request(request: dict[str, Any]) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 243, + "span": { + "end": { + "byte": 9280, + "column": 17, + "line": 243 + }, + "start": { + "byte": 6785, + "column": 0, + "line": 184 + } + }, + "start_line": 184 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/execute_request", + "identity": "execute_request", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main() -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 304, + "span": { + "end": { + "byte": 11656, + "column": 11, + "line": 304 + }, + "start": { + "byte": 11625, + "column": 0, + "line": 303 + } + }, + "start_line": 303 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/serve/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "serve", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_broker.py::function:serve", + "decorators": [], + "kind": "function", + "name": "serve", + "parent_identity": null, + "qualified_name": "serve", + "signature": "def serve() -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "432e9529fc831f30baf6920e5df75f34de6dcc9172aa4dbbb0d1cc44d4f154ec", + "file": "vm-mcp/admin_broker.py", + "location": { + "end_line": 300, + "span": { + "end": { + "byte": 11622, + "column": 95, + "line": 300 + }, + "start": { + "byte": 10146, + "column": 0, + "line": 272 + } + }, + "start_line": 272 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_broker.py#subject/symbol/serve", + "identity": "serve", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "15:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A88-88/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "15:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 88, + "start_line": 88 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "5:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A88-88/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "5:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 88, + "start_line": 88 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "46:33" + } + }, + "origin": "native", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A88-88/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "46:33" + } + }, + "origin": "native", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 88, + "start_line": 88 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_client.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=46:33 imports_exports=5:1 calls_definitions=15:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 71, + "column": 71, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "identity": "vm-mcp/admin_client.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_client.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: vm_mcp_admin_client\n module_name: vm_mcp_admin_client\n module_kind: adapter\n summary: sends bounded personal-console execution requests from the non-root MCP service to the local root broker\n owner: skill-lib vm-mcp maintainers\n public_surface: request_exec\n internal_surface: AF_UNIX JSON request/response transport\n auth_boundary: admin\n storage_boundary: none\n network_boundary: local\n user_data_boundary: read_write\n admin_only: true\n tests: vm-mcp/tests/test_assets.py\n rollout: imported by policy.py only in personal-console profile\n rollback: return deployment to workspace/read-only profile\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 31, + "span": { + "end": { + "byte": 1115, + "column": 26, + "line": 31 + }, + "start": { + "byte": 419, + "column": 0, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "identity": "vm-mcp/admin_client.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_client.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== BOUNDARIES ===\nid: vm_mcp_admin_client_socket_boundary\n summary: connects only to the configured local Unix-domain broker socket and sends no SSH/cloud credentials\n auth_boundary: admin\n storage_boundary: none\n network_boundary: local\n user_data_boundary: read_write\n admin_only: true\n side_effects: process\n owner: skill-lib vm-mcp maintainers\n=== END BOUNDARIES ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 43, + "span": { + "end": { + "byte": 1518, + "column": 24, + "line": 43 + }, + "start": { + "byte": 1117, + "column": 0, + "line": 33 + } + }, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "identity": "vm-mcp/admin_client.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_client.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=46:33 imports_exports=5:1 calls_definitions=15:1" + } + }, + "origin": "native", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 88, + "span": { + "end": { + "byte": 2973, + "column": 71, + "line": 88 + }, + "start": { + "byte": 2902, + "column": 0, + "line": 88 + } + }, + "start_line": 88 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "identity": "vm-mcp/admin_client.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_client.py::<module>", + "description": "Usage guidance: call :func:`request_exec` only from the non-root MCP service.\nThe broker socket is local-only and must be owned by root with group access for\n``vmmcp``.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Unix-socket client for the vm-mcp personal-console broker.", + "text": "Unix-socket client for the vm-mcp personal-console broker.\n\nUsage guidance: call :func:`request_exec` only from the non-root MCP service.\nThe broker socket is local-only and must be owned by root with group access for\n``vmmcp``.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 7, + "span": { + "end": { + "byte": 307, + "column": 3, + "line": 7 + }, + "start": { + "byte": 72, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "identity": "vm-mcp/admin_client.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "identity": "vm-mcp/admin_client.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "json:json:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "json", + "name": "json" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "identity": "vm-mcp/admin_client.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "socket:socket:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "socket", + "name": "socket" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "identity": "vm-mcp/admin_client.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "identity": "vm-mcp/admin_client.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/module/vm-mcp%2Fadmin_client.py", + "identity": "vm-mcp/admin_client.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/symbol/request_exec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "request_exec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/admin_client.py::function:request_exec", + "decorators": [], + "kind": "function", + "name": "request_exec", + "parent_identity": null, + "qualified_name": "request_exec", + "signature": "def request_exec(*, socket_path: Path, mode: str, user: str | None, command: str, cwd: str, timeout_seconds: float, max_output_bytes: int) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "52f33760e485c15ef4dcd9dcbad37038b480b14899fc023df1fc152730e49313", + "file": "vm-mcp/admin_client.py", + "location": { + "end_line": 87, + "span": { + "end": { + "byte": 2901, + "column": 19, + "line": 87 + }, + "start": { + "byte": 1559, + "column": 0, + "line": 48 + } + }, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/admin_client.py#subject/symbol/request_exec", + "identity": "request_exec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A2-2/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "55b57034b88fd2d4237286d20b007d38853c34389ef1c0d8a35647c288a6a64c", + "file": "vm-mcp/install.sh", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A151-151/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "55b57034b88fd2d4237286d20b007d38853c34389ef1c0d8a35647c288a6a64c", + "file": "vm-mcp/install.sh", + "location": { + "end_line": 151, + "start_line": 151 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A2-2/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "55b57034b88fd2d4237286d20b007d38853c34389ef1c0d8a35647c288a6a64c", + "file": "vm-mcp/install.sh", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A151-151/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "55b57034b88fd2d4237286d20b007d38853c34389ef1c0d8a35647c288a6a64c", + "file": "vm-mcp/install.sh", + "location": { + "end_line": 151, + "start_line": 151 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A2-2/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "55b57034b88fd2d4237286d20b007d38853c34389ef1c0d8a35647c288a6a64c", + "file": "vm-mcp/install.sh", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A151-151/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "hmmm" + } + }, + "origin": "native", + "source": { + "content_sha256": "55b57034b88fd2d4237286d20b007d38853c34389ef1c0d8a35647c288a6a64c", + "file": "vm-mcp/install.sh", + "location": { + "end_line": 151, + "start_line": 151 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/vm-mcp%2Finstall.sh/fact/interpreter/lines%3A1-1/shebang", + "convention": { + "dialect": "sh", + "namespace": "posix.shebang", + "version": "source declaration v1" + }, + "extraction": { + "configuration_sha256": "64715d255639d911f2d3cd2803a93b14b7288f30528cb729d844c119cd1f8637", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "shell-static", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "interpreter", + "native": { + "id": "shebang", + "value": { + "shebang": "/usr/bin/env bash" + } + }, + "origin": "native", + "source": { + "content_sha256": "55b57034b88fd2d4237286d20b007d38853c34389ef1c0d8a35647c288a6a64c", + "file": "vm-mcp/install.sh", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/install.sh#subject/file/vm-mcp%2Finstall.sh", + "identity": "vm-mcp/install.sh", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "134:24" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A481-481/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "134:24" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 481, + "start_line": 481 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "13:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A481-481/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "13:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 481, + "start_line": 481 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "374:57" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A481-481/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "374:57" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 481, + "start_line": 481 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=374:57 imports_exports=13:12 calls_definitions=134:24" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 76, + "column": 76, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CONTRACTS ===\nid: vm_mcp_read_paths_confined\n given: a file or directory tool receives a relative path, absolute path, parent traversal, or symlink target\n then: the resolved target must remain under VM_MCP_ROOT or the tool refuses access\n class: security\n\nid: vm_mcp_listing_symlinks_not_followed\n given: a directory listing encounters a symlink whose target is outside VM_MCP_ROOT\n then: the listing reports the symlink itself and does not follow the target for file metadata\n class: security\n\nid: vm_mcp_output_bounded\n given: a file, directory, or process result exceeds its configured response limit\n then: the response is capped and reports truncation visibly\n class: safety\n\nid: vm_mcp_profile_default_read_only\n given: the service starts without an explicit profile\n then: writes, shell execution, user execution, and admin execution are refused\n class: security\n\nid: vm_mcp_workspace_writes_confined\n given: a workspace write, move, directory creation, or removal is requested\n then: the resolved path remains under VM_MCP_ROOT and the profile must permit workspace mutation\n class: security\n\nid: vm_mcp_shell_cwd_confined\n given: shell execution receives a working directory outside VM_MCP_ROOT or through an escaping symlink\n then: execution is refused before a process is spawned\n class: security\n\nid: vm_mcp_shell_execution_bounded\n given: shell execution emits excessive output, exceeds its timeout, or tries to leave background descendants running\n then: output is capped, timed-out process groups are killed, and surviving descendants are killed before return\n class: safety\n\nid: vm_mcp_credentials_not_inherited\n given: the MCP service process has unrelated environment variables or host credentials\n then: shell execution receives a sanitized environment rather than the service process environment\n class: security\n\nid: vm_mcp_personal_console_explicit\n given: user_exec or admin_exec is requested\n then: the deployment must explicitly select the personal-console profile\n class: security\n=== END CONTRACTS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 72, + "span": { + "end": { + "byte": 3014, + "column": 23, + "line": 72 + }, + "start": { + "byte": 870, + "column": 0, + "line": 27 + } + }, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=374:57 imports_exports=13:12 calls_definitions=134:24" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 481, + "span": { + "end": { + "byte": 17433, + "column": 76, + "line": 481 + }, + "start": { + "byte": 17357, + "column": 0, + "line": 481 + } + }, + "start_line": 481 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::<module>", + "description": "Usage guidance:\n- Construct :class:`VmMcpConfig` from the service environment.\n- Keep the default ``read-only`` profile for shared or first-contact installs.\n- Use ``workspace`` for root-confined writes and shell execution.\n- Use ``personal-console`` only for a single-owner private VM where broad\n ``user_exec`` and explicit ``admin_exec`` are intended.\n- Systemd confinement remains the host-write boundary for the non-root service;\n personal-console host/root execution crosses a separate Unix-socket broker.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Policy primitives for the vm-mcp runtime.", + "text": "Policy primitives for the vm-mcp runtime.\n\nUsage guidance:\n- Construct :class:`VmMcpConfig` from the service environment.\n- Keep the default ``read-only`` profile for shared or first-contact installs.\n- Use ``workspace`` for root-confined writes and shell execution.\n- Use ``personal-console`` only for a single-owner private VM where broad\n ``user_exec`` and explicit ``admin_exec`` are intended.\n- Systemd confinement remains the host-write boundary for the non-root service;\n personal-console host/root execution crosses a separate Unix-socket broker.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 12, + "span": { + "end": { + "byte": 640, + "column": 3, + "line": 12 + }, + "start": { + "byte": 77, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 24, + "start_line": 24 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:11", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 25, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pwd:pwd:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "pwd", + "name": "pwd" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "selectors:selectors:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "selectors", + "name": "selectors" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "shutil:shutil:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "shutil", + "name": "shutil" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "signal:signal:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "signal", + "name": "signal" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "socket:socket:6", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "socket", + "name": "socket" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "subprocess:subprocess:7", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "subprocess", + "name": "subprocess" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "time:time:8", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "time", + "name": "time" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "dataclasses:dataclass:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "dataclasses", + "name": "dataclass" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 23, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/module/vm-mcp%2Fpolicy.py", + "identity": "vm-mcp/policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig.from_env/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "nearest_enclosing_symbol", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::method:VmMcpConfig.from_env", + "metadata_kind": "comment", + "text": "Backward compatibility with the first vm-mcp release." + } + }, + "origin": "native", + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 110, + "span": { + "end": { + "byte": 4132, + "column": 67, + "line": 110 + }, + "start": { + "byte": 4077, + "column": 12, + "line": 110 + } + }, + "start_line": 110 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig.from_env", + "identity": "VmMcpConfig.from_env", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig.from_env/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpConfig.from_env", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::method:VmMcpConfig.from_env", + "decorators": [ + "classmethod" + ], + "kind": "method", + "name": "from_env", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::class:VmMcpConfig", + "qualified_name": "VmMcpConfig.from_env", + "signature": "def from_env(cls) -> 'VmMcpConfig'" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 132, + "span": { + "end": { + "byte": 5222, + "column": 9, + "line": 132 + }, + "start": { + "byte": 3917, + "column": 4, + "line": 106 + } + }, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig.from_env", + "identity": "VmMcpConfig.from_env", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig.personal_console_enabled/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpConfig.personal_console_enabled", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::method:VmMcpConfig.personal_console_enabled", + "decorators": [ + "property" + ], + "kind": "method", + "name": "personal_console_enabled", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::class:VmMcpConfig", + "qualified_name": "VmMcpConfig.personal_console_enabled", + "signature": "def personal_console_enabled(self) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 104, + "span": { + "end": { + "byte": 3911, + "column": 49, + "line": 104 + }, + "start": { + "byte": 3804, + "column": 4, + "line": 102 + } + }, + "start_line": 102 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig.personal_console_enabled", + "identity": "VmMcpConfig.personal_console_enabled", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig.shell_enabled/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpConfig.shell_enabled", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::method:VmMcpConfig.shell_enabled", + "decorators": [ + "property" + ], + "kind": "method", + "name": "shell_enabled", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::class:VmMcpConfig", + "qualified_name": "VmMcpConfig.shell_enabled", + "signature": "def shell_enabled(self) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 100, + "span": { + "end": { + "byte": 3798, + "column": 64, + "line": 100 + }, + "start": { + "byte": 3687, + "column": 4, + "line": 98 + } + }, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig.shell_enabled", + "identity": "VmMcpConfig.shell_enabled", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig.workspace_write_enabled/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpConfig.workspace_write_enabled", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::method:VmMcpConfig.workspace_write_enabled", + "decorators": [ + "property" + ], + "kind": "method", + "name": "workspace_write_enabled", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::class:VmMcpConfig", + "qualified_name": "VmMcpConfig.workspace_write_enabled", + "signature": "def workspace_write_enabled(self) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 96, + "span": { + "end": { + "byte": 3681, + "column": 64, + "line": 96 + }, + "start": { + "byte": 3560, + "column": 4, + "line": 94 + } + }, + "start_line": 94 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig.workspace_write_enabled", + "identity": "VmMcpConfig.workspace_write_enabled", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "VmMcpConfig", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::class:VmMcpConfig", + "decorators": [ + "dataclass(frozen=True)" + ], + "kind": "class", + "name": "VmMcpConfig", + "parent_identity": null, + "qualified_name": "VmMcpConfig", + "signature": "class VmMcpConfig" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 132, + "span": { + "end": { + "byte": 5222, + "column": 9, + "line": 132 + }, + "start": { + "byte": 3345, + "column": 0, + "line": 84 + } + }, + "start_line": 84 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/VmMcpConfig", + "identity": "VmMcpConfig", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_communicate_bounded/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_communicate_bounded", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:_communicate_bounded", + "decorators": [], + "kind": "function", + "name": "_communicate_bounded", + "parent_identity": null, + "qualified_name": "_communicate_bounded", + "signature": "def _communicate_bounded(process: subprocess.Popen[bytes], *, timeout: float, limit: int) -> tuple[bytes, bytes, bool, bool, bool]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 412, + "span": { + "end": { + "byte": 15007, + "column": 5, + "line": 412 + }, + "start": { + "byte": 12641, + "column": 0, + "line": 357 + } + }, + "start_line": 357 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_communicate_bounded", + "identity": "_communicate_bounded", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_env_flag/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_env_flag", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:_env_flag", + "decorators": [], + "kind": "function", + "name": "_env_flag", + "parent_identity": null, + "qualified_name": "_env_flag", + "signature": "def _env_flag(name: str, *, default: bool) -> bool" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 139, + "span": { + "end": { + "byte": 5411, + "column": 60, + "line": 139 + }, + "start": { + "byte": 5225, + "column": 0, + "line": 135 + } + }, + "start_line": 135 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_env_flag", + "identity": "_env_flag", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_kill_group/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_kill_group", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:_kill_group", + "decorators": [], + "kind": "function", + "name": "_kill_group", + "parent_identity": null, + "qualified_name": "_kill_group", + "signature": "def _kill_group(process: subprocess.Popen[bytes]) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 354, + "span": { + "end": { + "byte": 12638, + "column": 12, + "line": 354 + }, + "start": { + "byte": 12480, + "column": 0, + "line": 350 + } + }, + "start_line": 350 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_kill_group", + "identity": "_kill_group", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_positive_float/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_positive_float", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:_positive_float", + "decorators": [], + "kind": "function", + "name": "_positive_float", + "parent_identity": null, + "qualified_name": "_positive_float", + "signature": "def _positive_float(raw: str | None, default: float) -> float" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 157, + "span": { + "end": { + "byte": 5897, + "column": 16, + "line": 157 + }, + "start": { + "byte": 5653, + "column": 0, + "line": 151 + } + }, + "start_line": 151 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_positive_float", + "identity": "_positive_float", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_positive_int/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_positive_int", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:_positive_int", + "decorators": [], + "kind": "function", + "name": "_positive_int", + "parent_identity": null, + "qualified_name": "_positive_int", + "signature": "def _positive_int(raw: str | None, default: int) -> int" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 148, + "span": { + "end": { + "byte": 5650, + "column": 16, + "line": 148 + }, + "start": { + "byte": 5414, + "column": 0, + "line": 142 + } + }, + "start_line": 142 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_positive_int", + "identity": "_positive_int", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_require_personal_console/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_require_personal_console", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:_require_personal_console", + "decorators": [], + "kind": "function", + "name": "_require_personal_console", + "parent_identity": null, + "qualified_name": "_require_personal_console", + "signature": "def _require_personal_console(config: VmMcpConfig) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 186, + "span": { + "end": { + "byte": 6974, + "column": 9, + "line": 186 + }, + "start": { + "byte": 6752, + "column": 0, + "line": 182 + } + }, + "start_line": 182 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_require_personal_console", + "identity": "_require_personal_console", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_require_workspace_write/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_require_workspace_write", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:_require_workspace_write", + "decorators": [], + "kind": "function", + "name": "_require_workspace_write", + "parent_identity": null, + "qualified_name": "_require_workspace_write", + "signature": "def _require_workspace_write(config: VmMcpConfig) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 179, + "span": { + "end": { + "byte": 6749, + "column": 9, + "line": 179 + }, + "start": { + "byte": 6512, + "column": 0, + "line": 175 + } + }, + "start_line": 175 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_require_workspace_write", + "identity": "_require_workspace_write", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_sanitized_subprocess_env/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_sanitized_subprocess_env", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:_sanitized_subprocess_env", + "decorators": [], + "kind": "function", + "name": "_sanitized_subprocess_env", + "parent_identity": null, + "qualified_name": "_sanitized_subprocess_env", + "signature": "def _sanitized_subprocess_env() -> dict[str, str]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 347, + "span": { + "end": { + "byte": 12477, + "column": 14, + "line": 347 + }, + "start": { + "byte": 11909, + "column": 0, + "line": 331 + } + }, + "start_line": 331 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/_sanitized_subprocess_env", + "identity": "_sanitized_subprocess_env", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/broker_exec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "broker_exec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:broker_exec", + "decorators": [], + "kind": "function", + "name": "broker_exec", + "parent_identity": null, + "qualified_name": "broker_exec", + "signature": "def broker_exec(config: VmMcpConfig, *, mode: str, command: str, cwd: str, user: str | None=None, timeout_seconds: float=60.0) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 480, + "span": { + "end": { + "byte": 17356, + "column": 5, + "line": 480 + }, + "start": { + "byte": 16465, + "column": 0, + "line": 454 + } + }, + "start_line": 454 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/broker_exec", + "identity": "broker_exec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/broker_exec/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "admin_client:request_exec:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "admin_client", + "name": "request_exec" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 471, + "start_line": 471 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/broker_exec", + "identity": "broker_exec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/list_directory/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "list_directory", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:list_directory", + "decorators": [], + "kind": "function", + "name": "list_directory", + "parent_identity": null, + "qualified_name": "list_directory", + "signature": "def list_directory(config: VmMcpConfig, requested: str='.', *, max_entries: int=200) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 231, + "span": { + "end": { + "byte": 8710, + "column": 95, + "line": 231 + }, + "start": { + "byte": 7805, + "column": 0, + "line": 210 + } + }, + "start_line": 210 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/list_directory", + "identity": "list_directory", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/make_directory/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "make_directory", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:make_directory", + "decorators": [], + "kind": "function", + "name": "make_directory", + "parent_identity": null, + "qualified_name": "make_directory", + "signature": "def make_directory(config: VmMcpConfig, requested: str, *, parents: bool=False) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 303, + "span": { + "end": { + "byte": 10936, + "column": 47, + "line": 303 + }, + "start": { + "byte": 10613, + "column": 0, + "line": 294 + } + }, + "start_line": 294 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/make_directory", + "identity": "make_directory", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/move_path/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "move_path", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:move_path", + "decorators": [], + "kind": "function", + "name": "move_path", + "parent_identity": null, + "qualified_name": "move_path", + "signature": "def move_path(config: VmMcpConfig, source: str, destination: str) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 313, + "span": { + "end": { + "byte": 11341, + "column": 56, + "line": 313 + }, + "start": { + "byte": 10939, + "column": 0, + "line": 306 + } + }, + "start_line": 306 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/move_path", + "identity": "move_path", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/read_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:read_text", + "decorators": [], + "kind": "function", + "name": "read_text", + "parent_identity": null, + "qualified_name": "read_text", + "signature": "def read_text(config: VmMcpConfig, requested: str, *, max_bytes: int=64 * 1024) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 254, + "span": { + "end": { + "byte": 9343, + "column": 5, + "line": 254 + }, + "start": { + "byte": 8713, + "column": 0, + "line": 234 + } + }, + "start_line": 234 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/read_text", + "identity": "read_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/remove_path/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "remove_path", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:remove_path", + "decorators": [], + "kind": "function", + "name": "remove_path", + "parent_identity": null, + "qualified_name": "remove_path", + "signature": "def remove_path(config: VmMcpConfig, requested: str, *, recursive: bool=False) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 328, + "span": { + "end": { + "byte": 11906, + "column": 71, + "line": 328 + }, + "start": { + "byte": 11344, + "column": 0, + "line": 316 + } + }, + "start_line": 316 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/remove_path", + "identity": "remove_path", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/resolve_under_root/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "resolve_under_root", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:resolve_under_root", + "decorators": [], + "kind": "function", + "name": "resolve_under_root", + "parent_identity": null, + "qualified_name": "resolve_under_root", + "signature": "def resolve_under_root(root: Path, requested: str, *, must_exist: bool=True) -> Path" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 172, + "span": { + "end": { + "byte": 6509, + "column": 20, + "line": 172 + }, + "start": { + "byte": 5900, + "column": 0, + "line": 160 + } + }, + "start_line": 160 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/resolve_under_root", + "identity": "resolve_under_root", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/run_shell/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "run_shell", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:run_shell", + "decorators": [], + "kind": "function", + "name": "run_shell", + "parent_identity": null, + "qualified_name": "run_shell", + "signature": "def run_shell(config: VmMcpConfig, command: str, *, cwd: str='.', timeout_seconds: float=60.0) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 451, + "span": { + "end": { + "byte": 16462, + "column": 5, + "line": 451 + }, + "start": { + "byte": 15010, + "column": 0, + "line": 415 + } + }, + "start_line": 415 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/run_shell", + "identity": "run_shell", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/stat_path/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "stat_path", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:stat_path", + "decorators": [], + "kind": "function", + "name": "stat_path", + "parent_identity": null, + "qualified_name": "stat_path", + "signature": "def stat_path(config: VmMcpConfig, requested: str) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 268, + "span": { + "end": { + "byte": 9801, + "column": 5, + "line": 268 + }, + "start": { + "byte": 9346, + "column": 0, + "line": 257 + } + }, + "start_line": 257 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/stat_path", + "identity": "stat_path", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/vm_info/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "vm_info", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:vm_info", + "decorators": [], + "kind": "function", + "name": "vm_info", + "parent_identity": null, + "qualified_name": "vm_info", + "signature": "def vm_info(config: VmMcpConfig) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 207, + "span": { + "end": { + "byte": 7802, + "column": 5, + "line": 207 + }, + "start": { + "byte": 6977, + "column": 0, + "line": 189 + } + }, + "start_line": 189 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/vm_info", + "identity": "vm_info", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/write_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "write_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/policy.py::function:write_text", + "decorators": [], + "kind": "function", + "name": "write_text", + "parent_identity": null, + "qualified_name": "write_text", + "signature": "def write_text(config: VmMcpConfig, requested: str, text: str, *, create_parents: bool=False) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "ff57d9d890883995e9f6010e655a324e37597ff71c58fb0952894766ade3568b", + "file": "vm-mcp/policy.py", + "location": { + "end_line": 291, + "span": { + "end": { + "byte": 10610, + "column": 61, + "line": 291 + }, + "start": { + "byte": 9804, + "column": 0, + "line": 271 + } + }, + "start_line": 271 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/policy.py#subject/symbol/write_text", + "identity": "write_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/requirements.txt#subject/requirements-document/requirement%3A1/fact/dependency/lines%3A3-3/mcp", + "convention": { + "dialect": "requirements", + "namespace": "python.requirements-file", + "version": "PyPA requirements file subset v1" + }, + "extraction": { + "configuration_sha256": "c471ab3438cdba6c5142e03413c15f5d434f9e9bd7fa4ad5e20afbc9252949e2", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-requirements", + "reader_version": "1.0.0", + "support": "partial" + }, + "kind": "dependency", + "native": { + "id": "mcp", + "value": { + "class": "runtime-or-unresolved", + "name": "mcp", + "order": 1, + "requirement": "mcp>=2,<3" + } + }, + "origin": "native", + "projection": { + "loss": "resolution and environment markers not evaluated", + "mapping_version": "requirements-lines@1", + "relation": "depends_on" + }, + "source": { + "content_sha256": "32cb60f4c5a3643cee4294bf11c97bd618e51043e06be0c8c9f69cf2605a2bf7", + "file": "vm-mcp/requirements.txt", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/requirements.txt#subject/requirements-document/requirement%3A1", + "identity": "requirement:1", + "scope": "requirements-document" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/calls_definitions%5B1%5D/fact/composition-ratio/lines%3A1-1/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 1, + "ratio": "calls_definitions", + "value": "37:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/calls_definitions%5B1%5D", + "identity": "calls_definitions[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/calls_definitions%5B2%5D/fact/composition-ratio/lines%3A190-190/calls_definitions", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "calls_definitions", + "value": { + "occurrence": 2, + "ratio": "calls_definitions", + "value": "37:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 190, + "start_line": 190 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/calls_definitions%5B2%5D", + "identity": "calls_definitions[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/imports_exports%5B1%5D/fact/composition-ratio/lines%3A1-1/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 1, + "ratio": "imports_exports", + "value": "6:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/imports_exports%5B1%5D", + "identity": "imports_exports[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/imports_exports%5B2%5D/fact/composition-ratio/lines%3A190-190/imports_exports", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "imports_exports", + "value": { + "occurrence": 2, + "ratio": "imports_exports", + "value": "6:12" + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 190, + "start_line": 190 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/imports_exports%5B2%5D", + "identity": "imports_exports[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/loc_comments%5B1%5D/fact/composition-ratio/lines%3A1-1/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 1, + "ratio": "loc_comments", + "value": "89:60" + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 1, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/loc_comments%5B1%5D", + "identity": "loc_comments[1]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/loc_comments%5B2%5D/fact/composition-ratio/lines%3A190-190/loc_comments", + "convention": { + "dialect": "line-comment:#", + "namespace": "msdmd.ratios-line", + "version": "named ratios line v1" + }, + "extraction": { + "configuration_sha256": "845819620aa224e67b08544dbe57bcf9b3ae5aff62a2c67899c412579aad9a64", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "composition-ratio", + "native": { + "id": "loc_comments", + "value": { + "occurrence": 2, + "ratio": "loc_comments", + "value": "89:60" + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 190, + "start_line": 190 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/file/loc_comments%5B2%5D", + "identity": "loc_comments[2]", + "scope": "file" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=89:60 imports_exports=6:12 calls_definitions=37:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 73, + "column": 73, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/comment/1", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== MODULE_BUILD ===\nid: vm_mcp_control_plane\n module_name: vm_mcp_control_plane\n module_kind: service\n summary: exposes loopback-only VM inspection, workspace mutation, confined shell, and explicit personal-console user/root execution surfaces\n owner: skill-lib vm-mcp maintainers\n public_surface: vm_info, list_directory, read_text, stat_path, write_text, make_directory, move_path, remove_path, shell_exec, user_exec, admin_exec\n internal_surface: policy.py, admin_client.py, admin_broker.py\n auth_boundary: admin\n storage_boundary: write\n network_boundary: external\n user_data_boundary: read_write\n admin_only: true\n tests: vm-mcp/tests/test_policy.py, vm-mcp/tests/test_assets.py, vm-mcp/tests/test_admin_broker.py\n rollout: root_installer_plus_systemd_plus_private_mcp_tunnel\n rollback: disable vm-mcp services and remove private client registration\n feature_flag: VM_MCP_PROFILE\n unresolved: client_specific_private_tunnel_registration, application_layer_auth_when_not_using_a_private_tunnel\n=== END MODULE_BUILD ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 53, + "span": { + "end": { + "byte": 2181, + "column": 26, + "line": 53 + }, + "start": { + "byte": 1104, + "column": 0, + "line": 35 + } + }, + "start_line": 35 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/comment/2", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CONTRACTS ===\nid: vm_mcp_loopback_only\n given: the MCP server starts with its shipped runtime configuration\n then: Streamable HTTP binds to 127.0.0.1 on /mcp rather than a public interface\n class: security\n\nid: vm_mcp_host_write_confined\n given: the non-root MCP service starts with its shipped systemd configuration\n then: NoNewPrivileges remains enabled, Linux capabilities are empty, and direct service writes stay under VM_MCP_ROOT\n class: security\n\nid: vm_mcp_metadata_credentials_blocked\n given: the non-root MCP service attempts to reach the standard cloud metadata-service address\n then: the systemd network policy denies 169.254.169.254\n class: security\n\nid: vm_mcp_personal_console_root_separate\n given: personal-console admin_exec is enabled\n then: root execution occurs only in the separate Unix-socket broker and not by making the MCP service root\n class: authority\n=== END CONTRACTS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 75, + "span": { + "end": { + "byte": 3138, + "column": 23, + "line": 75 + }, + "start": { + "byte": 2183, + "column": 0, + "line": 55 + } + }, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/comment/3", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::<module>", + "metadata_kind": "msdmd_ratios", + "text": "ratios: loc_comments=89:60 imports_exports=6:12 calls_definitions=37:14" + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 190, + "span": { + "end": { + "byte": 7441, + "column": 73, + "line": 190 + }, + "start": { + "byte": 7368, + "column": 0, + "line": 190 + } + }, + "start_line": 190 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::<module>", + "description": "Usage guidance:\n VM_MCP_PROFILE=read-only python server.py\n VM_MCP_PROFILE=workspace python server.py\n VM_MCP_PROFILE=personal-console python server.py\n\nThe service always binds to loopback. ``personal-console`` additionally exposes\nexplicit ``user_exec`` and ``admin_exec`` through the separate root broker; use\nthat profile only for a single-owner private VM behind an authenticated tunnel.", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "MCP server for bounded or personal-console access to a private Linux VM.", + "text": "MCP server for bounded or personal-console access to a private Linux VM.\n\nUsage guidance:\n VM_MCP_PROFILE=read-only python server.py\n VM_MCP_PROFILE=workspace python server.py\n VM_MCP_PROFILE=personal-console python server.py\n\nThe service always binds to loopback. ``personal-console`` additionally exposes\nexplicit ``user_exec`` and ``admin_exec`` through the separate root broker; use\nthat profile only for a single-owner private VM behind an authenticated tunnel.\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 12, + "span": { + "end": { + "byte": 556, + "column": 3, + "line": 12 + }, + "start": { + "byte": 74, + "column": 0, + "line": 2 + } + }, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:move_path:10", + "value": { + "alias": "policy_move_path", + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "move_path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 33, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:read_text:11", + "value": { + "alias": "policy_read_text", + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "read_text" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 33, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/12", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:remove_path:12", + "value": { + "alias": "policy_remove_path", + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "remove_path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 33, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/13", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:run_shell:13", + "value": { + "alias": "policy_run_shell", + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "run_shell" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 33, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/14", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:stat_path:14", + "value": { + "alias": "policy_stat_path", + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "stat_path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 33, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/15", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:vm_info:15", + "value": { + "alias": "policy_vm_info", + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "vm_info" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 33, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/16", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:write_text:16", + "value": { + "alias": "policy_write_text", + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "write_text" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 33, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Any:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Any" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "typing:Callable:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "typing", + "name": "Callable" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "mcp.server:MCPServer:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "mcp.server", + "name": "MCPServer" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "mcp.types:ToolAnnotations:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "mcp.types", + "name": "ToolAnnotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:VmMcpConfig:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "VmMcpConfig" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 33, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:broker_exec:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "broker_exec" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 33, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:list_directory:8", + "value": { + "alias": "policy_list_directory", + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "list_directory" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 33, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:make_directory:9", + "value": { + "alias": "policy_make_directory", + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "make_directory" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 33, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/module/vm-mcp%2Fserver.py", + "identity": "vm-mcp/server.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/_config/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_config", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:_config", + "decorators": [], + "kind": "function", + "name": "_config", + "parent_identity": null, + "qualified_name": "_config", + "signature": "def _config() -> VmMcpConfig" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 86, + "span": { + "end": { + "byte": 3641, + "column": 33, + "line": 86 + }, + "start": { + "byte": 3578, + "column": 0, + "line": 85 + } + }, + "start_line": 85 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/_config", + "identity": "_config", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/_result/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "_result", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:_result", + "decorators": [], + "kind": "function", + "name": "_result", + "parent_identity": null, + "qualified_name": "_result", + "signature": "def _result(call: Callable[[], dict[str, Any]]) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 93, + "span": { + "end": { + "byte": 3911, + "column": 81, + "line": 93 + }, + "start": { + "byte": 3644, + "column": 0, + "line": 89 + } + }, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/_result", + "identity": "_result", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/admin_exec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "admin_exec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:admin_exec", + "decorators": [ + "mcp.tool(annotations=ADMIN_SHELL)" + ], + "kind": "function", + "name": "admin_exec", + "parent_identity": null, + "qualified_name": "admin_exec", + "signature": "def admin_exec(command: str, cwd: str='/', timeout_seconds: float=60.0) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 174, + "span": { + "end": { + "byte": 7072, + "column": 5, + "line": 174 + }, + "start": { + "byte": 6676, + "column": 0, + "line": 166 + } + }, + "start_line": 166 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/admin_exec", + "identity": "admin_exec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/admin_exec/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:admin_exec", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Personal-console only: execute an explicitly privileged command as root.", + "text": "Personal-console only: execute an explicitly privileged command as root." + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 168, + "span": { + "end": { + "byte": 6888, + "column": 82, + "line": 168 + }, + "start": { + "byte": 6810, + "column": 4, + "line": 168 + } + }, + "start_line": 168 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/admin_exec", + "identity": "admin_exec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/list_directory/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "list_directory", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:list_directory", + "decorators": [ + "mcp.tool(annotations=READ_ONLY)" + ], + "kind": "function", + "name": "list_directory", + "parent_identity": null, + "qualified_name": "list_directory", + "signature": "def list_directory(path: str='.', max_entries: int=200) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 105, + "span": { + "end": { + "byte": 4409, + "column": 91, + "line": 105 + }, + "start": { + "byte": 4123, + "column": 0, + "line": 102 + } + }, + "start_line": 102 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/list_directory", + "identity": "list_directory", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/list_directory/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:list_directory", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "List one directory under VM_MCP_ROOT without following outside symlinks.", + "text": "List one directory under VM_MCP_ROOT without following outside symlinks." + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 104, + "span": { + "end": { + "byte": 4317, + "column": 82, + "line": 104 + }, + "start": { + "byte": 4239, + "column": 4, + "line": 104 + } + }, + "start_line": 104 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/list_directory", + "identity": "list_directory", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/main/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "main", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:main", + "decorators": [], + "kind": "function", + "name": "main", + "parent_identity": null, + "qualified_name": "main", + "signature": "def main() -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 185, + "span": { + "end": { + "byte": 7327, + "column": 5, + "line": 185 + }, + "start": { + "byte": 7075, + "column": 0, + "line": 177 + } + }, + "start_line": 177 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/main", + "identity": "main", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/make_directory/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "make_directory", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:make_directory", + "decorators": [ + "mcp.tool(annotations=WRITE_FS)" + ], + "kind": "function", + "name": "make_directory", + "parent_identity": null, + "qualified_name": "make_directory", + "signature": "def make_directory(path: str, parents: bool=False) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 129, + "span": { + "end": { + "byte": 5402, + "column": 83, + "line": 129 + }, + "start": { + "byte": 5167, + "column": 0, + "line": 126 + } + }, + "start_line": 126 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/make_directory", + "identity": "make_directory", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/make_directory/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:make_directory", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Create a directory under VM_MCP_ROOT.", + "text": "Create a directory under VM_MCP_ROOT." + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 128, + "span": { + "end": { + "byte": 5318, + "column": 47, + "line": 128 + }, + "start": { + "byte": 5275, + "column": 4, + "line": 128 + } + }, + "start_line": 128 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/make_directory", + "identity": "make_directory", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/move_path/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "move_path", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:move_path", + "decorators": [ + "mcp.tool(annotations=WRITE_FS)" + ], + "kind": "function", + "name": "move_path", + "parent_identity": null, + "qualified_name": "move_path", + "signature": "def move_path(source: str, destination: str) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 5651, + "column": 76, + "line": 135 + }, + "start": { + "byte": 5405, + "column": 0, + "line": 132 + } + }, + "start_line": 132 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/move_path", + "identity": "move_path", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/move_path/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:move_path", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Atomically move one path to another location under VM_MCP_ROOT.", + "text": "Atomically move one path to another location under VM_MCP_ROOT." + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 134, + "span": { + "end": { + "byte": 5574, + "column": 73, + "line": 134 + }, + "start": { + "byte": 5505, + "column": 4, + "line": 134 + } + }, + "start_line": 134 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/move_path", + "identity": "move_path", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/read_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "read_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:read_text", + "decorators": [ + "mcp.tool(annotations=READ_ONLY)" + ], + "kind": "function", + "name": "read_text", + "parent_identity": null, + "qualified_name": "read_text", + "signature": "def read_text(path: str, max_bytes: int=65536) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 111, + "span": { + "end": { + "byte": 4671, + "column": 82, + "line": 111 + }, + "start": { + "byte": 4412, + "column": 0, + "line": 108 + } + }, + "start_line": 108 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/read_text", + "identity": "read_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/read_text/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:read_text", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Read bounded UTF-8-compatible text from a file under VM_MCP_ROOT.", + "text": "Read bounded UTF-8-compatible text from a file under VM_MCP_ROOT." + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 110, + "span": { + "end": { + "byte": 4588, + "column": 75, + "line": 110 + }, + "start": { + "byte": 4517, + "column": 4, + "line": 110 + } + }, + "start_line": 110 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/read_text", + "identity": "read_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/remove_path/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "remove_path", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:remove_path", + "decorators": [ + "mcp.tool(annotations=WRITE_SHELL)" + ], + "kind": "function", + "name": "remove_path", + "parent_identity": null, + "qualified_name": "remove_path", + "signature": "def remove_path(path: str, recursive: bool=False) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 141, + "span": { + "end": { + "byte": 5927, + "column": 84, + "line": 141 + }, + "start": { + "byte": 5654, + "column": 0, + "line": 138 + } + }, + "start_line": 138 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/remove_path", + "identity": "remove_path", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/remove_path/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:remove_path", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Remove a file/symlink or, when requested, a directory under VM_MCP_ROOT.", + "text": "Remove a file/symlink or, when requested, a directory under VM_MCP_ROOT." + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 140, + "span": { + "end": { + "byte": 5842, + "column": 82, + "line": 140 + }, + "start": { + "byte": 5764, + "column": 4, + "line": 140 + } + }, + "start_line": 140 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/remove_path", + "identity": "remove_path", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/shell_exec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "shell_exec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:shell_exec", + "decorators": [ + "mcp.tool(annotations=WRITE_SHELL)" + ], + "kind": "function", + "name": "shell_exec", + "parent_identity": null, + "qualified_name": "shell_exec", + "signature": "def shell_exec(command: str, cwd: str='.', timeout_seconds: float=60.0) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 147, + "span": { + "end": { + "byte": 6252, + "column": 106, + "line": 147 + }, + "start": { + "byte": 5930, + "column": 0, + "line": 144 + } + }, + "start_line": 144 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/shell_exec", + "identity": "shell_exec", + "scope": "symbol" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/shell_exec/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:shell_exec", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Run one bounded shell command as the confined non-root vm-mcp service user.", + "text": "Run one bounded shell command as the confined non-root vm-mcp service user." + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 146, + "span": { + "end": { + "byte": 6145, + "column": 85, + "line": 146 + }, + "start": { + "byte": 6064, + "column": 4, + "line": 146 + } + }, + "start_line": 146 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/shell_exec", + "identity": "shell_exec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/stat_path/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "stat_path", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:stat_path", + "decorators": [ + "mcp.tool(annotations=READ_ONLY)" + ], + "kind": "function", + "name": "stat_path", + "parent_identity": null, + "qualified_name": "stat_path", + "signature": "def stat_path(path: str) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 117, + "span": { + "end": { + "byte": 4878, + "column": 61, + "line": 117 + }, + "start": { + "byte": 4674, + "column": 0, + "line": 114 + } + }, + "start_line": 114 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/stat_path", + "identity": "stat_path", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/stat_path/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:stat_path", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return bounded metadata for one path under VM_MCP_ROOT.", + "text": "Return bounded metadata for one path under VM_MCP_ROOT." + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 116, + "span": { + "end": { + "byte": 4816, + "column": 65, + "line": 116 + }, + "start": { + "byte": 4755, + "column": 4, + "line": 116 + } + }, + "start_line": 116 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/stat_path", + "identity": "stat_path", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/user_exec/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "user_exec", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:user_exec", + "decorators": [ + "mcp.tool(annotations=WRITE_SHELL)" + ], + "kind": "function", + "name": "user_exec", + "parent_identity": null, + "qualified_name": "user_exec", + "signature": "def user_exec(user: str, command: str, cwd: str='/', timeout_seconds: float=60.0) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 163, + "span": { + "end": { + "byte": 6673, + "column": 5, + "line": 163 + }, + "start": { + "byte": 6255, + "column": 0, + "line": 150 + } + }, + "start_line": 150 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/user_exec", + "identity": "user_exec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/user_exec/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:user_exec", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Personal-console only: execute as an explicit local non-root user.", + "text": "Personal-console only: execute as an explicit local non-root user." + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 157, + "span": { + "end": { + "byte": 6490, + "column": 76, + "line": 157 + }, + "start": { + "byte": 6418, + "column": 4, + "line": 157 + } + }, + "start_line": 157 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/user_exec", + "identity": "user_exec", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/vm_info/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "vm_info", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:vm_info", + "decorators": [ + "mcp.tool(annotations=READ_ONLY)" + ], + "kind": "function", + "name": "vm_info", + "parent_identity": null, + "qualified_name": "vm_info", + "signature": "def vm_info() -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 99, + "span": { + "end": { + "byte": 4120, + "column": 53, + "line": 99 + }, + "start": { + "byte": 3914, + "column": 0, + "line": 96 + } + }, + "start_line": 96 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/vm_info", + "identity": "vm_info", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/vm_info/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:vm_info", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Return service identity, profile, workspace root, broker socket, and limits.", + "text": "Return service identity, profile, workspace root, broker socket, and limits." + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 98, + "span": { + "end": { + "byte": 4066, + "column": 86, + "line": 98 + }, + "start": { + "byte": 3984, + "column": 4, + "line": 98 + } + }, + "start_line": 98 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/vm_info", + "identity": "vm_info", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/write_text/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "write_text", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:write_text", + "decorators": [ + "mcp.tool(annotations=WRITE_FS)" + ], + "kind": "function", + "name": "write_text", + "parent_identity": null, + "qualified_name": "write_text", + "signature": "def write_text(path: str, text: str, create_parents: bool=False) -> dict[str, Any]" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 123, + "span": { + "end": { + "byte": 5164, + "column": 99, + "line": 123 + }, + "start": { + "byte": 4881, + "column": 0, + "line": 120 + } + }, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/write_text", + "identity": "write_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/write_text/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/server.py::function:write_text", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Atomically write one UTF-8 text file under VM_MCP_ROOT.", + "text": "Atomically write one UTF-8 text file under VM_MCP_ROOT." + } + }, + "origin": "native", + "source": { + "content_sha256": "c994e0ff3b2efc2de4d443a93320733736679ebda5e2513c034580bf68830391", + "file": "vm-mcp/server.py", + "location": { + "end_line": 122, + "span": { + "end": { + "byte": 5064, + "column": 65, + "line": 122 + }, + "start": { + "byte": 5003, + "column": 4, + "line": 122 + } + }, + "start_line": 122 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/server.py#subject/symbol/write_text", + "identity": "write_text", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Install.WantedBy%5B1%5D/fact/unit-directive/lines%3A25-25/WantedBy", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "WantedBy", + "value": { + "key": "WantedBy", + "occurrence": 1, + "section": "Install", + "value": "multi-user.target" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 25, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Install.WantedBy%5B1%5D", + "identity": "Install.WantedBy[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Environment%5B1%5D/fact/unit-directive/lines%3A11-11/Environment", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Environment", + "value": { + "key": "Environment", + "occurrence": 1, + "section": "Service", + "value": "VM_MCP_ADMIN_SOCKET=/run/vm-mcp/admin.sock" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Environment%5B1%5D", + "identity": "Service.Environment[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Environment%5B2%5D/fact/unit-directive/lines%3A12-12/Environment", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Environment", + "value": { + "key": "Environment", + "occurrence": 2, + "section": "Service", + "value": "VM_MCP_CALLER_USER=vmmcp" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Environment%5B2%5D", + "identity": "Service.Environment[2]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Environment%5B3%5D/fact/unit-directive/lines%3A13-13/Environment", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Environment", + "value": { + "key": "Environment", + "occurrence": 3, + "section": "Service", + "value": "PYTHONDONTWRITEBYTECODE=1" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Environment%5B3%5D", + "identity": "Service.Environment[3]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.ExecStart%5B1%5D/fact/unit-directive/lines%3A14-14/ExecStart", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ExecStart", + "value": { + "key": "ExecStart", + "occurrence": 1, + "section": "Service", + "value": "/opt/vm-mcp/.venv/bin/python /opt/vm-mcp/admin_broker.py" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.ExecStart%5B1%5D", + "identity": "Service.ExecStart[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Group%5B1%5D/fact/unit-directive/lines%3A9-9/Group", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Group", + "value": { + "key": "Group", + "occurrence": 1, + "section": "Service", + "value": "root" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Group%5B1%5D", + "identity": "Service.Group[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.LimitNOFILE%5B1%5D/fact/unit-directive/lines%3A22-22/LimitNOFILE", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "LimitNOFILE", + "value": { + "key": "LimitNOFILE", + "occurrence": 1, + "section": "Service", + "value": "4096" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.LimitNOFILE%5B1%5D", + "identity": "Service.LimitNOFILE[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Restart%5B1%5D/fact/unit-directive/lines%3A15-15/Restart", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Restart", + "value": { + "key": "Restart", + "occurrence": 1, + "section": "Service", + "value": "on-failure" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Restart%5B1%5D", + "identity": "Service.Restart[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.RestartSec%5B1%5D/fact/unit-directive/lines%3A16-16/RestartSec", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "RestartSec", + "value": { + "key": "RestartSec", + "occurrence": 1, + "section": "Service", + "value": "2" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.RestartSec%5B1%5D", + "identity": "Service.RestartSec[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.RestrictAddressFamilies%5B1%5D/fact/unit-directive/lines%3A20-20/RestrictAddressFamilies", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "RestrictAddressFamilies", + "value": { + "key": "RestrictAddressFamilies", + "occurrence": 1, + "section": "Service", + "value": "AF_UNIX" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.RestrictAddressFamilies%5B1%5D", + "identity": "Service.RestrictAddressFamilies[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.RuntimeDirectory%5B1%5D/fact/unit-directive/lines%3A18-18/RuntimeDirectory", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "RuntimeDirectory", + "value": { + "key": "RuntimeDirectory", + "occurrence": 1, + "section": "Service", + "value": "vm-mcp" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.RuntimeDirectory%5B1%5D", + "identity": "Service.RuntimeDirectory[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.RuntimeDirectoryMode%5B1%5D/fact/unit-directive/lines%3A19-19/RuntimeDirectoryMode", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "RuntimeDirectoryMode", + "value": { + "key": "RuntimeDirectoryMode", + "occurrence": 1, + "section": "Service", + "value": "0750" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.RuntimeDirectoryMode%5B1%5D", + "identity": "Service.RuntimeDirectoryMode[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.TasksMax%5B1%5D/fact/unit-directive/lines%3A21-21/TasksMax", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "TasksMax", + "value": { + "key": "TasksMax", + "occurrence": 1, + "section": "Service", + "value": "256" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.TasksMax%5B1%5D", + "identity": "Service.TasksMax[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Type%5B1%5D/fact/unit-directive/lines%3A7-7/Type", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Type", + "value": { + "key": "Type", + "occurrence": 1, + "section": "Service", + "value": "simple" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.Type%5B1%5D", + "identity": "Service.Type[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.UMask%5B1%5D/fact/unit-directive/lines%3A17-17/UMask", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "UMask", + "value": { + "key": "UMask", + "occurrence": 1, + "section": "Service", + "value": "0077" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.UMask%5B1%5D", + "identity": "Service.UMask[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.User%5B1%5D/fact/unit-directive/lines%3A8-8/User", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "User", + "value": { + "key": "User", + "occurrence": 1, + "section": "Service", + "value": "root" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.User%5B1%5D", + "identity": "Service.User[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.WorkingDirectory%5B1%5D/fact/unit-directive/lines%3A10-10/WorkingDirectory", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "WorkingDirectory", + "value": { + "key": "WorkingDirectory", + "occurrence": 1, + "section": "Service", + "value": "/opt/vm-mcp" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Service.WorkingDirectory%5B1%5D", + "identity": "Service.WorkingDirectory[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Unit.After%5B1%5D/fact/unit-directive/lines%3A3-3/After", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "After", + "value": { + "key": "After", + "occurrence": 1, + "section": "Unit", + "value": "local-fs.target" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Unit.After%5B1%5D", + "identity": "Unit.After[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Unit.Before%5B1%5D/fact/unit-directive/lines%3A4-4/Before", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Before", + "value": { + "key": "Before", + "occurrence": 1, + "section": "Unit", + "value": "vm-mcp.service" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Unit.Before%5B1%5D", + "identity": "Unit.Before[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Unit.Description%5B1%5D/fact/unit-directive/lines%3A2-2/Description", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Description", + "value": { + "key": "Description", + "occurrence": 1, + "section": "Unit", + "value": "skill-lib VM MCP personal-console root broker" + } + }, + "origin": "native", + "source": { + "content_sha256": "87e50ce56696f12cbafa1d30ca81f7e4eebc5bb4c225013d3bee912f9a3c1f11", + "file": "vm-mcp/systemd/vm-mcp-admin.service", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp-admin.service#subject/configuration/Unit.Description%5B1%5D", + "identity": "Unit.Description[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Install.WantedBy%5B1%5D/fact/unit-directive/lines%3A47-47/WantedBy", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "WantedBy", + "value": { + "key": "WantedBy", + "occurrence": 1, + "section": "Install", + "value": "multi-user.target" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 47, + "start_line": 47 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Install.WantedBy%5B1%5D", + "identity": "Install.WantedBy[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.AmbientCapabilities%5B1%5D/fact/unit-directive/lines%3A38-38/AmbientCapabilities", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "AmbientCapabilities", + "value": { + "key": "AmbientCapabilities", + "occurrence": 1, + "section": "Service", + "value": "" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 38, + "start_line": 38 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.AmbientCapabilities%5B1%5D", + "identity": "Service.AmbientCapabilities[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.CapabilityBoundingSet%5B1%5D/fact/unit-directive/lines%3A37-37/CapabilityBoundingSet", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "CapabilityBoundingSet", + "value": { + "key": "CapabilityBoundingSet", + "occurrence": 1, + "section": "Service", + "value": "" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 37, + "start_line": 37 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.CapabilityBoundingSet%5B1%5D", + "identity": "Service.CapabilityBoundingSet[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Environment%5B1%5D/fact/unit-directive/lines%3A12-12/Environment", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Environment", + "value": { + "key": "Environment", + "occurrence": 1, + "section": "Service", + "value": "VM_MCP_ROOT=/srv/vm-mcp/workspace" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Environment%5B1%5D", + "identity": "Service.Environment[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Environment%5B2%5D/fact/unit-directive/lines%3A13-13/Environment", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Environment", + "value": { + "key": "Environment", + "occurrence": 2, + "section": "Service", + "value": "VM_MCP_PROFILE=read-only" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Environment%5B2%5D", + "identity": "Service.Environment[2]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Environment%5B3%5D/fact/unit-directive/lines%3A14-14/Environment", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Environment", + "value": { + "key": "Environment", + "occurrence": 3, + "section": "Service", + "value": "VM_MCP_PORT=8765" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 14, + "start_line": 14 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Environment%5B3%5D", + "identity": "Service.Environment[3]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Environment%5B4%5D/fact/unit-directive/lines%3A15-15/Environment", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Environment", + "value": { + "key": "Environment", + "occurrence": 4, + "section": "Service", + "value": "VM_MCP_ADMIN_SOCKET=/run/vm-mcp/admin.sock" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 15, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Environment%5B4%5D", + "identity": "Service.Environment[4]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Environment%5B5%5D/fact/unit-directive/lines%3A16-16/Environment", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Environment", + "value": { + "key": "Environment", + "occurrence": 5, + "section": "Service", + "value": "PYTHONDONTWRITEBYTECODE=1" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 16, + "start_line": 16 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Environment%5B5%5D", + "identity": "Service.Environment[5]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.EnvironmentFile%5B1%5D/fact/unit-directive/lines%3A11-11/EnvironmentFile", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "EnvironmentFile", + "value": { + "key": "EnvironmentFile", + "occurrence": 1, + "section": "Service", + "value": "-/etc/vm-mcp.env" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.EnvironmentFile%5B1%5D", + "identity": "Service.EnvironmentFile[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ExecStart%5B1%5D/fact/unit-directive/lines%3A17-17/ExecStart", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ExecStart", + "value": { + "key": "ExecStart", + "occurrence": 1, + "section": "Service", + "value": "/opt/vm-mcp/.venv/bin/python /opt/vm-mcp/server.py" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 17, + "start_line": 17 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ExecStart%5B1%5D", + "identity": "Service.ExecStart[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Group%5B1%5D/fact/unit-directive/lines%3A9-9/Group", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Group", + "value": { + "key": "Group", + "occurrence": 1, + "section": "Service", + "value": "vmmcp" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Group%5B1%5D", + "identity": "Service.Group[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.IPAddressDeny%5B1%5D/fact/unit-directive/lines%3A41-41/IPAddressDeny", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "IPAddressDeny", + "value": { + "key": "IPAddressDeny", + "occurrence": 1, + "section": "Service", + "value": "169.254.169.254" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 41, + "start_line": 41 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.IPAddressDeny%5B1%5D", + "identity": "Service.IPAddressDeny[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.InaccessiblePaths%5B1%5D/fact/unit-directive/lines%3A40-40/InaccessiblePaths", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "InaccessiblePaths", + "value": { + "key": "InaccessiblePaths", + "occurrence": 1, + "section": "Service", + "value": "-/run/docker.sock -/var/run/docker.sock" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 40, + "start_line": 40 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.InaccessiblePaths%5B1%5D", + "identity": "Service.InaccessiblePaths[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.LimitNOFILE%5B1%5D/fact/unit-directive/lines%3A44-44/LimitNOFILE", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "LimitNOFILE", + "value": { + "key": "LimitNOFILE", + "occurrence": 1, + "section": "Service", + "value": "4096" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 44, + "start_line": 44 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.LimitNOFILE%5B1%5D", + "identity": "Service.LimitNOFILE[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.LockPersonality%5B1%5D/fact/unit-directive/lines%3A36-36/LockPersonality", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "LockPersonality", + "value": { + "key": "LockPersonality", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 36, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.LockPersonality%5B1%5D", + "identity": "Service.LockPersonality[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.NoNewPrivileges%5B1%5D/fact/unit-directive/lines%3A21-21/NoNewPrivileges", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "NoNewPrivileges", + "value": { + "key": "NoNewPrivileges", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 21, + "start_line": 21 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.NoNewPrivileges%5B1%5D", + "identity": "Service.NoNewPrivileges[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.PrivateDevices%5B1%5D/fact/unit-directive/lines%3A23-23/PrivateDevices", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "PrivateDevices", + "value": { + "key": "PrivateDevices", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 23, + "start_line": 23 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.PrivateDevices%5B1%5D", + "identity": "Service.PrivateDevices[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.PrivateTmp%5B1%5D/fact/unit-directive/lines%3A22-22/PrivateTmp", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "PrivateTmp", + "value": { + "key": "PrivateTmp", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 22, + "start_line": 22 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.PrivateTmp%5B1%5D", + "identity": "Service.PrivateTmp[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProcSubset%5B1%5D/fact/unit-directive/lines%3A33-33/ProcSubset", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ProcSubset", + "value": { + "key": "ProcSubset", + "occurrence": 1, + "section": "Service", + "value": "pid" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 33, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProcSubset%5B1%5D", + "identity": "Service.ProcSubset[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectClock%5B1%5D/fact/unit-directive/lines%3A30-30/ProtectClock", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ProtectClock", + "value": { + "key": "ProtectClock", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 30, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectClock%5B1%5D", + "identity": "Service.ProtectClock[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectControlGroups%5B1%5D/fact/unit-directive/lines%3A26-26/ProtectControlGroups", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ProtectControlGroups", + "value": { + "key": "ProtectControlGroups", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 26, + "start_line": 26 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectControlGroups%5B1%5D", + "identity": "Service.ProtectControlGroups[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectHome%5B1%5D/fact/unit-directive/lines%3A25-25/ProtectHome", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ProtectHome", + "value": { + "key": "ProtectHome", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 25, + "start_line": 25 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectHome%5B1%5D", + "identity": "Service.ProtectHome[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectHostname%5B1%5D/fact/unit-directive/lines%3A31-31/ProtectHostname", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ProtectHostname", + "value": { + "key": "ProtectHostname", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 31, + "start_line": 31 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectHostname%5B1%5D", + "identity": "Service.ProtectHostname[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectKernelLogs%5B1%5D/fact/unit-directive/lines%3A29-29/ProtectKernelLogs", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ProtectKernelLogs", + "value": { + "key": "ProtectKernelLogs", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 29, + "start_line": 29 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectKernelLogs%5B1%5D", + "identity": "Service.ProtectKernelLogs[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectKernelModules%5B1%5D/fact/unit-directive/lines%3A28-28/ProtectKernelModules", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ProtectKernelModules", + "value": { + "key": "ProtectKernelModules", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 28, + "start_line": 28 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectKernelModules%5B1%5D", + "identity": "Service.ProtectKernelModules[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectKernelTunables%5B1%5D/fact/unit-directive/lines%3A27-27/ProtectKernelTunables", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ProtectKernelTunables", + "value": { + "key": "ProtectKernelTunables", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 27, + "start_line": 27 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectKernelTunables%5B1%5D", + "identity": "Service.ProtectKernelTunables[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectProc%5B1%5D/fact/unit-directive/lines%3A32-32/ProtectProc", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ProtectProc", + "value": { + "key": "ProtectProc", + "occurrence": 1, + "section": "Service", + "value": "invisible" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 32, + "start_line": 32 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectProc%5B1%5D", + "identity": "Service.ProtectProc[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectSystem%5B1%5D/fact/unit-directive/lines%3A24-24/ProtectSystem", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ProtectSystem", + "value": { + "key": "ProtectSystem", + "occurrence": 1, + "section": "Service", + "value": "strict" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 24, + "start_line": 24 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ProtectSystem%5B1%5D", + "identity": "Service.ProtectSystem[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ReadWritePaths%5B1%5D/fact/unit-directive/lines%3A39-39/ReadWritePaths", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "ReadWritePaths", + "value": { + "key": "ReadWritePaths", + "occurrence": 1, + "section": "Service", + "value": "/srv/vm-mcp/workspace" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 39, + "start_line": 39 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.ReadWritePaths%5B1%5D", + "identity": "Service.ReadWritePaths[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Restart%5B1%5D/fact/unit-directive/lines%3A18-18/Restart", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Restart", + "value": { + "key": "Restart", + "occurrence": 1, + "section": "Service", + "value": "on-failure" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 18, + "start_line": 18 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Restart%5B1%5D", + "identity": "Service.Restart[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.RestartSec%5B1%5D/fact/unit-directive/lines%3A19-19/RestartSec", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "RestartSec", + "value": { + "key": "RestartSec", + "occurrence": 1, + "section": "Service", + "value": "2" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 19, + "start_line": 19 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.RestartSec%5B1%5D", + "identity": "Service.RestartSec[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.RestrictAddressFamilies%5B1%5D/fact/unit-directive/lines%3A42-42/RestrictAddressFamilies", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "RestrictAddressFamilies", + "value": { + "key": "RestrictAddressFamilies", + "occurrence": 1, + "section": "Service", + "value": "AF_UNIX AF_INET AF_INET6" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 42, + "start_line": 42 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.RestrictAddressFamilies%5B1%5D", + "identity": "Service.RestrictAddressFamilies[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.RestrictRealtime%5B1%5D/fact/unit-directive/lines%3A35-35/RestrictRealtime", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "RestrictRealtime", + "value": { + "key": "RestrictRealtime", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 35, + "start_line": 35 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.RestrictRealtime%5B1%5D", + "identity": "Service.RestrictRealtime[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.RestrictSUIDSGID%5B1%5D/fact/unit-directive/lines%3A34-34/RestrictSUIDSGID", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "RestrictSUIDSGID", + "value": { + "key": "RestrictSUIDSGID", + "occurrence": 1, + "section": "Service", + "value": "true" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 34, + "start_line": 34 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.RestrictSUIDSGID%5B1%5D", + "identity": "Service.RestrictSUIDSGID[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.TasksMax%5B1%5D/fact/unit-directive/lines%3A43-43/TasksMax", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "TasksMax", + "value": { + "key": "TasksMax", + "occurrence": 1, + "section": "Service", + "value": "256" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 43, + "start_line": 43 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.TasksMax%5B1%5D", + "identity": "Service.TasksMax[1]", + "scope": "configuration" + } + } + ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Type%5B1%5D/fact/unit-directive/lines%3A7-7/Type", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Type", + "value": { + "key": "Type", + "occurrence": 1, + "section": "Service", + "value": "simple" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 7, + "start_line": 7 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.Type%5B1%5D", + "identity": "Service.Type[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.UMask%5B1%5D/fact/unit-directive/lines%3A20-20/UMask", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "UMask", + "value": { + "key": "UMask", + "occurrence": 1, + "section": "Service", + "value": "0077" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 20, + "start_line": 20 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.UMask%5B1%5D", + "identity": "Service.UMask[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.User%5B1%5D/fact/unit-directive/lines%3A8-8/User", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "User", + "value": { + "key": "User", + "occurrence": 1, + "section": "Service", + "value": "vmmcp" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.User%5B1%5D", + "identity": "Service.User[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.WorkingDirectory%5B1%5D/fact/unit-directive/lines%3A10-10/WorkingDirectory", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "WorkingDirectory", + "value": { + "key": "WorkingDirectory", + "occurrence": 1, + "section": "Service", + "value": "/opt/vm-mcp" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Service.WorkingDirectory%5B1%5D", + "identity": "Service.WorkingDirectory[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Unit.After%5B1%5D/fact/unit-directive/lines%3A3-3/After", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "After", + "value": { + "key": "After", + "occurrence": 1, + "section": "Unit", + "value": "network-online.target" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 3, + "start_line": 3 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Unit.After%5B1%5D", + "identity": "Unit.After[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Unit.Description%5B1%5D/fact/unit-directive/lines%3A2-2/Description", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Description", + "value": { + "key": "Description", + "occurrence": 1, + "section": "Unit", + "value": "skill-lib VM MCP control plane" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Unit.Description%5B1%5D", + "identity": "Unit.Description[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Unit.Wants%5B1%5D/fact/unit-directive/lines%3A4-4/Wants", + "convention": { + "dialect": "service", + "namespace": "systemd.unit", + "version": "systemd.syntax current documented grammar" + }, + "extraction": { + "configuration_sha256": "214b4dfb76672113efae39ea39f97e602f6c074ac1253adc2da9ec2228430c3b", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "support": "implemented-and-tested" + }, + "kind": "unit-directive", + "native": { + "id": "Wants", + "value": { + "key": "Wants", + "occurrence": 1, + "section": "Unit", + "value": "network-online.target" + } + }, + "origin": "native", + "source": { + "content_sha256": "ec9b8feae2df69ce97625d154ba090e1fe96a22495f0dda263af794dc339e818", + "file": "vm-mcp/systemd/vm-mcp.service", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/systemd/vm-mcp.service#subject/configuration/Unit.Wants%5B1%5D", + "identity": "Unit.Wants[1]", + "scope": "configuration" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CHECKS ===\nid: check_vm_mcp_user_exec_non_root\n proves: vm_mcp_user_exec_non_root\n call: self::test_user_mode_rejects_root\n mutates: none\n cleanup: none\n\nid: check_vm_mcp_admin_exec_explicit_root\n proves: vm_mcp_admin_exec_explicit_root\n call: self::test_admin_mode_selects_root\n mutates: none\n cleanup: none\n\nid: check_vm_mcp_broker_execution_bounded\n proves: vm_mcp_broker_execution_bounded\n call: self::test_admin_execution_timeout_is_bounded_when_root\n mutates: process\n cleanup: process_group_killed\n\nid: check_vm_mcp_admin_broker_peer_verified\n proves: vm_mcp_admin_broker_peer_verified\n call: self::test_serve_source_uses_peer_credentials\n mutates: none\n cleanup: none\n=== END CHECKS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 28, + "span": { + "end": { + "byte": 871, + "column": 20, + "line": 28 + }, + "start": { + "byte": 110, + "column": 0, + "line": 4 + } + }, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "identity": "vm-mcp/tests/test_admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Contract tests for personal-console user/root execution separation.", + "text": "Contract tests for personal-console user/root execution separation." + } + }, + "origin": "native", + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 73, + "column": 73, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "identity": "vm-mcp/tests/test_admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "identity": "vm-mcp/tests/test_admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pwd:pwd:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "pwd", + "name": "pwd" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 30, + "start_line": 30 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "identity": "vm-mcp/tests/test_admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 31, + "start_line": 31 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "identity": "vm-mcp/tests/test_admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:3", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 32, + "start_line": 32 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "identity": "vm-mcp/tests/test_admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest.mock:patch:4", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "unittest.mock", + "name": "patch" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 33, + "start_line": 33 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "identity": "vm-mcp/tests/test_admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "admin_broker:admin_broker:5", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "admin_broker", + "name": "admin_broker" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 35, + "start_line": 35 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/module/vm-mcp%2Ftests%2Ftest_admin_broker.py", + "identity": "vm-mcp/tests/test_admin_broker.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_admin_execution_timeout_is_bounded_when_root/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAdminBrokerTests.test_admin_execution_timeout_is_bounded_when_root", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::method:VmMcpAdminBrokerTests.test_admin_execution_timeout_is_bounded_when_root", + "decorators": [], + "kind": "method", + "name": "test_admin_execution_timeout_is_bounded_when_root", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::class:VmMcpAdminBrokerTests", + "qualified_name": "VmMcpAdminBrokerTests.test_admin_execution_timeout_is_bounded_when_root", + "signature": "def test_admin_execution_timeout_is_bounded_when_root(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 70, + "span": { + "end": { + "byte": 2538, + "column": 46, + "line": 70 + }, + "start": { + "byte": 2066, + "column": 4, + "line": 61 + } + }, + "start_line": 61 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_admin_execution_timeout_is_bounded_when_root", + "identity": "VmMcpAdminBrokerTests.test_admin_execution_timeout_is_bounded_when_root", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_admin_execution_timeout_is_bounded_when_root/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:0", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 62, + "start_line": 62 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_admin_execution_timeout_is_bounded_when_root", + "identity": "VmMcpAdminBrokerTests.test_admin_execution_timeout_is_bounded_when_root", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_admin_mode_selects_root/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAdminBrokerTests.test_admin_mode_selects_root", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::method:VmMcpAdminBrokerTests.test_admin_mode_selects_root", + "decorators": [], + "kind": "method", + "name": "test_admin_mode_selects_root", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::class:VmMcpAdminBrokerTests", + "qualified_name": "VmMcpAdminBrokerTests.test_admin_mode_selects_root", + "signature": "def test_admin_mode_selects_root(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 46, + "span": { + "end": { + "byte": 1398, + "column": 49, + "line": 46 + }, + "start": { + "byte": 1190, + "column": 4, + "line": 43 + } + }, + "start_line": 43 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_admin_mode_selects_root", + "identity": "VmMcpAdminBrokerTests.test_admin_mode_selects_root", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_execution_requires_root_broker_process/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAdminBrokerTests.test_execution_requires_root_broker_process", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::method:VmMcpAdminBrokerTests.test_execution_requires_root_broker_process", + "decorators": [], + "kind": "method", + "name": "test_execution_requires_root_broker_process", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::class:VmMcpAdminBrokerTests", + "qualified_name": "VmMcpAdminBrokerTests.test_execution_requires_root_broker_process", + "signature": "def test_execution_requires_root_broker_process(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 84, + "span": { + "end": { + "byte": 3290, + "column": 33, + "line": 84 + }, + "start": { + "byte": 2916, + "column": 4, + "line": 79 + } + }, + "start_line": 79 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_execution_requires_root_broker_process", + "identity": "VmMcpAdminBrokerTests.test_execution_requires_root_broker_process", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_request_rejects_empty_command_before_spawn/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAdminBrokerTests.test_request_rejects_empty_command_before_spawn", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::method:VmMcpAdminBrokerTests.test_request_rejects_empty_command_before_spawn", + "decorators": [], + "kind": "method", + "name": "test_request_rejects_empty_command_before_spawn", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::class:VmMcpAdminBrokerTests", + "qualified_name": "VmMcpAdminBrokerTests.test_request_rejects_empty_command_before_spawn", + "signature": "def test_request_rejects_empty_command_before_spawn(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 77, + "span": { + "end": { + "byte": 2910, + "column": 33, + "line": 77 + }, + "start": { + "byte": 2544, + "column": 4, + "line": 72 + } + }, + "start_line": 72 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_request_rejects_empty_command_before_spawn", + "identity": "VmMcpAdminBrokerTests.test_request_rejects_empty_command_before_spawn", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_serve_source_uses_peer_credentials/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAdminBrokerTests.test_serve_source_uses_peer_credentials", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::method:VmMcpAdminBrokerTests.test_serve_source_uses_peer_credentials", + "decorators": [], + "kind": "method", + "name": "test_serve_source_uses_peer_credentials", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::class:VmMcpAdminBrokerTests", + "qualified_name": "VmMcpAdminBrokerTests.test_serve_source_uses_peer_credentials", + "signature": "def test_serve_source_uses_peer_credentials(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 59, + "span": { + "end": { + "byte": 2060, + "column": 59, + "line": 59 + }, + "start": { + "byte": 1771, + "column": 4, + "line": 55 + } + }, + "start_line": 55 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_serve_source_uses_peer_credentials", + "identity": "VmMcpAdminBrokerTests.test_serve_source_uses_peer_credentials", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_user_mode_rejects_root/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAdminBrokerTests.test_user_mode_rejects_root", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::method:VmMcpAdminBrokerTests.test_user_mode_rejects_root", + "decorators": [], + "kind": "method", + "name": "test_user_mode_rejects_root", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::class:VmMcpAdminBrokerTests", + "qualified_name": "VmMcpAdminBrokerTests.test_user_mode_rejects_root", + "signature": "def test_user_mode_rejects_root(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 41, + "span": { + "end": { + "byte": 1184, + "column": 61, + "line": 41 + }, + "start": { + "byte": 1032, + "column": 4, + "line": 39 + } + }, + "start_line": 39 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_user_mode_rejects_root", + "identity": "VmMcpAdminBrokerTests.test_user_mode_rejects_root", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_user_mode_selects_non_root_account/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAdminBrokerTests.test_user_mode_selects_non_root_account", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::method:VmMcpAdminBrokerTests.test_user_mode_selects_non_root_account", + "decorators": [], + "kind": "method", + "name": "test_user_mode_selects_non_root_account", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::class:VmMcpAdminBrokerTests", + "qualified_name": "VmMcpAdminBrokerTests.test_user_mode_selects_non_root_account", + "signature": "def test_user_mode_selects_non_root_account(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 53, + "span": { + "end": { + "byte": 1765, + "column": 56, + "line": 53 + }, + "start": { + "byte": 1404, + "column": 4, + "line": 48 + } + }, + "start_line": 48 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests.test_user_mode_selects_non_root_account", + "identity": "VmMcpAdminBrokerTests.test_user_mode_selects_non_root_account", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "VmMcpAdminBrokerTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_admin_broker.py::class:VmMcpAdminBrokerTests", + "decorators": [], + "kind": "class", + "name": "VmMcpAdminBrokerTests", + "parent_identity": null, + "qualified_name": "VmMcpAdminBrokerTests", + "signature": "class VmMcpAdminBrokerTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "a215dc574a70f2ecf3b0092ac8170d04d04a8ba8809be2ad79f687f449b0013a", + "file": "vm-mcp/tests/test_admin_broker.py", + "location": { + "end_line": 84, + "span": { + "end": { + "byte": 3290, + "column": 33, + "line": 84 + }, + "start": { + "byte": 980, + "column": 0, + "line": 38 + } + }, + "start_line": 38 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_admin_broker.py#subject/symbol/VmMcpAdminBrokerTests", + "identity": "VmMcpAdminBrokerTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CHECKS ===\nid: check_vm_mcp_loopback_config\n proves: vm_mcp_loopback_only\n call: self::test_server_binds_loopback_only\n mutates: none\n cleanup: none\n\nid: check_vm_mcp_systemd_write_boundary\n proves: vm_mcp_host_write_confined\n call: self::test_non_root_service_keeps_hardening\n mutates: none\n cleanup: none\n\nid: check_vm_mcp_metadata_denial\n proves: vm_mcp_metadata_credentials_blocked\n call: self::test_systemd_blocks_cloud_metadata_address\n mutates: none\n cleanup: none\n\nid: check_vm_mcp_personal_console_root_separate\n proves: vm_mcp_personal_console_root_separate\n call: self::test_personal_console_uses_separate_root_broker\n mutates: none\n cleanup: none\n=== END CHECKS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 33, + "span": { + "end": { + "byte": 925, + "column": 20, + "line": 33 + }, + "start": { + "byte": 181, + "column": 0, + "line": 9 + } + }, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py", + "identity": "vm-mcp/tests/test_assets.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::<module>", + "description": null, + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Static contract checks for vm-mcp deployment assets.", + "text": "Static contract checks for vm-mcp deployment assets." + } + }, + "origin": "native", + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 1, + "span": { + "end": { + "byte": 58, + "column": 58, + "line": 1 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py", + "identity": "vm-mcp/tests/test_assets.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 2, + "start_line": 2 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py", + "identity": "vm-mcp/tests/test_assets.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 4, + "start_line": 4 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py", + "identity": "vm-mcp/tests/test_assets.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:2", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 5, + "start_line": 5 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/module/vm-mcp%2Ftests%2Ftest_assets.py", + "identity": "vm-mcp/tests/test_assets.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_installer_preserves_existing_workspace_ownership/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAssetTests.test_installer_preserves_existing_workspace_ownership", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::method:VmMcpAssetTests.test_installer_preserves_existing_workspace_ownership", + "decorators": [], + "kind": "method", + "name": "test_installer_preserves_existing_workspace_ownership", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::class:VmMcpAssetTests", + "qualified_name": "VmMcpAssetTests.test_installer_preserves_existing_workspace_ownership", + "signature": "def test_installer_preserves_existing_workspace_ownership(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 77, + "span": { + "end": { + "byte": 3249, + "column": 116, + "line": 77 + }, + "start": { + "byte": 2937, + "column": 4, + "line": 74 + } + }, + "start_line": 74 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_installer_preserves_existing_workspace_ownership", + "identity": "VmMcpAssetTests.test_installer_preserves_existing_workspace_ownership", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_non_root_service_keeps_hardening/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAssetTests.test_non_root_service_keeps_hardening", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::method:VmMcpAssetTests.test_non_root_service_keeps_hardening", + "decorators": [], + "kind": "method", + "name": "test_non_root_service_keeps_hardening", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::class:VmMcpAssetTests", + "qualified_name": "VmMcpAssetTests.test_non_root_service_keeps_hardening", + "signature": "def test_non_root_service_keeps_hardening(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 54, + "span": { + "end": { + "byte": 1767, + "column": 41, + "line": 54 + }, + "start": { + "byte": 1250, + "column": 4, + "line": 43 + } + }, + "start_line": 43 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_non_root_service_keeps_hardening", + "identity": "VmMcpAssetTests.test_non_root_service_keeps_hardening", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_personal_console_uses_separate_root_broker/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAssetTests.test_personal_console_uses_separate_root_broker", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::method:VmMcpAssetTests.test_personal_console_uses_separate_root_broker", + "decorators": [], + "kind": "method", + "name": "test_personal_console_uses_separate_root_broker", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::class:VmMcpAssetTests", + "qualified_name": "VmMcpAssetTests.test_personal_console_uses_separate_root_broker", + "signature": "def test_personal_console_uses_separate_root_broker(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 72, + "span": { + "end": { + "byte": 2931, + "column": 163, + "line": 72 + }, + "start": { + "byte": 1982, + "column": 4, + "line": 60 + } + }, + "start_line": 60 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_personal_console_uses_separate_root_broker", + "identity": "VmMcpAssetTests.test_personal_console_uses_separate_root_broker", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_runtime_uses_current_v2_sdk/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAssetTests.test_runtime_uses_current_v2_sdk", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::method:VmMcpAssetTests.test_runtime_uses_current_v2_sdk", + "decorators": [], + "kind": "method", + "name": "test_runtime_uses_current_v2_sdk", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::class:VmMcpAssetTests", + "qualified_name": "VmMcpAssetTests.test_runtime_uses_current_v2_sdk", + "signature": "def test_runtime_uses_current_v2_sdk(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 84, + "span": { + "end": { + "byte": 3626, + "column": 59, + "line": 84 + }, + "start": { + "byte": 3255, + "column": 4, + "line": 79 + } + }, + "start_line": 79 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_runtime_uses_current_v2_sdk", + "identity": "VmMcpAssetTests.test_runtime_uses_current_v2_sdk", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_server_binds_loopback_only/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAssetTests.test_server_binds_loopback_only", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::method:VmMcpAssetTests.test_server_binds_loopback_only", + "decorators": [], + "kind": "method", + "name": "test_server_binds_loopback_only", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::class:VmMcpAssetTests", + "qualified_name": "VmMcpAssetTests.test_server_binds_loopback_only", + "signature": "def test_server_binds_loopback_only(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 41, + "span": { + "end": { + "byte": 1244, + "column": 48, + "line": 41 + }, + "start": { + "byte": 974, + "column": 4, + "line": 37 + } + }, + "start_line": 37 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_server_binds_loopback_only", + "identity": "VmMcpAssetTests.test_server_binds_loopback_only", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_systemd_blocks_cloud_metadata_address/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpAssetTests.test_systemd_blocks_cloud_metadata_address", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::method:VmMcpAssetTests.test_systemd_blocks_cloud_metadata_address", + "decorators": [], + "kind": "method", + "name": "test_systemd_blocks_cloud_metadata_address", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::class:VmMcpAssetTests", + "qualified_name": "VmMcpAssetTests.test_systemd_blocks_cloud_metadata_address", + "signature": "def test_systemd_blocks_cloud_metadata_address(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 58, + "span": { + "end": { + "byte": 1976, + "column": 60, + "line": 58 + }, + "start": { + "byte": 1773, + "column": 4, + "line": 56 + } + }, + "start_line": 56 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests.test_systemd_blocks_cloud_metadata_address", + "identity": "VmMcpAssetTests.test_systemd_blocks_cloud_metadata_address", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "VmMcpAssetTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_assets.py::class:VmMcpAssetTests", + "decorators": [], + "kind": "class", + "name": "VmMcpAssetTests", + "parent_identity": null, + "qualified_name": "VmMcpAssetTests", + "signature": "class VmMcpAssetTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "7f637b0f7f224f46bacdaad247b8e81af97c793086464a84b0021cdf2d44d257", + "file": "vm-mcp/tests/test_assets.py", + "location": { + "end_line": 84, + "span": { + "end": { + "byte": 3626, + "column": 59, + "line": 84 + }, + "start": { + "byte": 928, + "column": 0, + "line": 36 + } + }, + "start_line": 36 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_assets.py#subject/symbol/VmMcpAssetTests", + "identity": "VmMcpAssetTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/comment/0", + "convention": { + "dialect": "python", + "namespace": "python.line-comment", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "comment", + "native": { + "id": null, + "value": { + "attachment": "module_convention", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::<module>", + "metadata_kind": "msdmd_block", + "text": "=== CHECKS ===\nid: check_vm_mcp_parent_escape_rejected\n proves: vm_mcp_read_paths_confined\n call: self::test_parent_escape_rejected\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_vm_mcp_symlink_escape_rejected\n proves: vm_mcp_read_paths_confined\n call: self::test_symlink_escape_rejected\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_vm_mcp_listing_symlink_not_followed\n proves: vm_mcp_listing_symlinks_not_followed\n call: self::test_listing_does_not_follow_symlink_metadata\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_vm_mcp_output_bounded\n proves: vm_mcp_output_bounded\n call: self::test_read_text_is_bounded\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_vm_mcp_profile_default_read_only\n proves: vm_mcp_profile_default_read_only\n call: self::test_default_profile_is_read_only\n mutates: process_environment\n cleanup: patch_dict_rollback\n\nid: check_vm_mcp_workspace_write_gate\n proves: vm_mcp_workspace_writes_confined\n call: self::test_write_requires_mutating_profile\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_vm_mcp_workspace_write_confined\n proves: vm_mcp_workspace_writes_confined\n call: self::test_write_and_move_remain_under_root\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_vm_mcp_personal_console_gate\n proves: vm_mcp_personal_console_explicit\n call: self::test_broker_exec_requires_personal_console\n mutates: none\n cleanup: none\n\nid: check_vm_mcp_shell_cwd_escape_rejected\n proves: vm_mcp_shell_cwd_confined\n call: self::test_shell_cwd_escape_rejected\n mutates: filesystem\n cleanup: tempdir_teardown\n\nid: check_vm_mcp_shell_output_bounded\n proves: vm_mcp_shell_execution_bounded\n call: self::test_shell_output_is_bounded_while_draining\n mutates: process\n cleanup: process_group_killed\n\nid: check_vm_mcp_shell_timeout\n proves: vm_mcp_shell_execution_bounded\n call: self::test_shell_timeout_is_enforced\n mutates: process\n cleanup: process_group_killed\n\nid: check_vm_mcp_environment_sanitized\n proves: vm_mcp_credentials_not_inherited\n call: self::test_shell_does_not_inherit_unrelated_environment\n mutates: process_environment\n cleanup: patch_dict_rollback\n=== END CHECKS ===" + } + }, + "origin": "native", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 87, + "span": { + "end": { + "byte": 2666, + "column": 20, + "line": 87 + }, + "start": { + "byte": 316, + "column": 0, + "line": 15 + } + }, + "start_line": 15 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/documentation/0", + "convention": { + "dialect": "python", + "namespace": "python.pep257", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "documentation", + "native": { + "id": null, + "value": { + "attachment": "native_docstring", + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::<module>", + "description": "Run:\n PYTHONPATH=vm-mcp python -m unittest discover -s vm-mcp/tests -p 'test_*.py'", + "fields": [], + "format": "rest", + "metadata_kind": "documentation", + "summary": "Contract tests for vm-mcp profiles, workspace policy, and confined shell.", + "text": "Contract tests for vm-mcp profiles, workspace policy, and confined shell.\n\nRun:\n PYTHONPATH=vm-mcp python -m unittest discover -s vm-mcp/tests -p 'test_*.py'\n" + } + }, + "origin": "native", + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 5, + "span": { + "end": { + "byte": 167, + "column": 3, + "line": 5 + }, + "start": { + "byte": 0, + "column": 0, + "line": 1 + } + }, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/0", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "__future__:annotations:0", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "__future__", + "name": "annotations" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 6, + "start_line": 6 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/1", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "os:os:1", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "os", + "name": "os" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 8, + "start_line": 8 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/10", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:move_path:10", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "move_path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 98, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/11", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:read_text:11", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "read_text" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 98, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/12", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:resolve_under_root:12", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "resolve_under_root" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 98, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/13", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:run_shell:13", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "run_shell" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 98, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/14", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:write_text:14", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "write_text" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 98, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/2", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "tempfile:tempfile:2", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "tempfile", + "name": "tempfile" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 9, + "start_line": 9 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/3", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "time:time:3", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "time", + "name": "time" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 10, + "start_line": 10 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/4", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest:unittest:4", + "value": { + "alias": null, + "kind": "import", + "level": 0, + "module": "unittest", + "name": "unittest" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 11, + "start_line": 11 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/5", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "pathlib:Path:5", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "pathlib", + "name": "Path" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 12, + "start_line": 12 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/6", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "unittest.mock:patch:6", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "unittest.mock", + "name": "patch" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 13, + "start_line": 13 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } }, { - "from": "org_rec_aggregation_runner", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "org_rec_aggregation_runner", - "to": "Codex" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/7", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:VmMcpConfig:7", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "VmMcpConfig" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 98, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } }, { - "from": "ratios_harmonic_explorer", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "ratios_harmonic_explorer", - "to": "The Interdependency" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/8", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:broker_exec:8", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "broker_exec" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 98, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } }, { - "from": "ratios_harmonic_explorer", - "kind": "requires", - "source_block": "MODULE_BUILD", - "source_id": "ratios_harmonic_explorer", - "to": "ratios_harmonic_math" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py/fact/import/9", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "dependency", + "native": { + "id": "policy:list_directory:9", + "value": { + "alias": null, + "kind": "from_import", + "level": 0, + "module": "policy", + "name": "list_directory" + } + }, + "origin": "native", + "projection": { + "loss": "conditions retained in source; resolution not executed", + "mapping_version": "python-imports@2", + "relation": "imports" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 98, + "start_line": 89 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/module/vm-mcp%2Ftests%2Ftest_policy.py", + "identity": "vm-mcp/tests/test_policy.py", + "scope": "module" + } }, { - "from": "ratios_harmonic_math", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "ratios_harmonic_math", - "to": "The Interdependency" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.config/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.config", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.config", + "decorators": [], + "kind": "method", + "name": "config", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.config", + "signature": "def config(self, *, profile: str='read-only', output: int=64) -> VmMcpConfig" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 118, + "span": { + "end": { + "byte": 3431, + "column": 9, + "line": 118 + }, + "start": { + "byte": 3061, + "column": 4, + "line": 109 + } + }, + "start_line": 109 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.config", + "identity": "VmMcpPolicyTests.config", + "scope": "symbol" + } }, { - "from": "repo_loto_evidence", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "repo_loto_evidence", - "to": "Way Seer Erin" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.setUp/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.setUp", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.setUp", + "decorators": [], + "kind": "method", + "name": "setUp", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.setUp", + "signature": "def setUp(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 104, + "span": { + "end": { + "byte": 2994, + "column": 40, + "line": 104 + }, + "start": { + "byte": 2879, + "column": 4, + "line": 102 + } + }, + "start_line": 102 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.setUp", + "identity": "VmMcpPolicyTests.setUp", + "scope": "symbol" + } }, { - "from": "repo_mutation_gate", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "repo_mutation_gate", - "to": "Way Seer Erin" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.tearDown/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.tearDown", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.tearDown", + "decorators": [], + "kind": "method", + "name": "tearDown", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.tearDown", + "signature": "def tearDown(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 107, + "span": { + "end": { + "byte": 3055, + "column": 27, + "line": 107 + }, + "start": { + "byte": 3000, + "column": 4, + "line": 106 + } + }, + "start_line": 106 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.tearDown", + "identity": "VmMcpPolicyTests.tearDown", + "scope": "symbol" + } }, { - "from": "skill_lib_ai_installer", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "skill_lib_ai_installer", - "to": "skill-lib" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_broker_exec_requires_personal_console/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_broker_exec_requires_personal_console", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_broker_exec_requires_personal_console", + "decorators": [], + "kind": "method", + "name": "test_broker_exec_requires_personal_console", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_broker_exec_requires_personal_console", + "signature": "def test_broker_exec_requires_personal_console(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 230, + "span": { + "end": { + "byte": 8424, + "column": 13, + "line": 230 + }, + "start": { + "byte": 8140, + "column": 4, + "line": 225 + } + }, + "start_line": 225 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_broker_exec_requires_personal_console", + "identity": "VmMcpPolicyTests.test_broker_exec_requires_personal_console", + "scope": "symbol" + } }, { - "from": "skill_lib_ai_installer", - "kind": "requires", - "source_block": "MODULE_BUILD", - "source_id": "skill_lib_ai_installer", - "to": "bash" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_default_profile_is_read_only/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_default_profile_is_read_only", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_default_profile_is_read_only", + "decorators": [], + "kind": "method", + "name": "test_default_profile_is_read_only", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_default_profile_is_read_only", + "signature": "def test_default_profile_is_read_only(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 126, + "span": { + "end": { + "byte": 3802, + "column": 57, + "line": 126 + }, + "start": { + "byte": 3437, + "column": 4, + "line": 120 + } + }, + "start_line": 120 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_default_profile_is_read_only", + "identity": "VmMcpPolicyTests.test_default_profile_is_read_only", + "scope": "symbol" + } }, { - "from": "skill_lib_ai_launcher", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "skill_lib_ai_launcher", - "to": "skill-lib" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_directory_listing_is_bounded/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_directory_listing_is_bounded", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_directory_listing_is_bounded", + "decorators": [], + "kind": "method", + "name": "test_directory_listing_is_bounded", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_directory_listing_is_bounded", + "signature": "def test_directory_listing_is_bounded(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 177, + "span": { + "end": { + "byte": 6095, + "column": 44, + "line": 177 + }, + "start": { + "byte": 5773, + "column": 4, + "line": 172 + } + }, + "start_line": 172 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_directory_listing_is_bounded", + "identity": "VmMcpPolicyTests.test_directory_listing_is_bounded", + "scope": "symbol" + } }, { - "from": "skill_lib_ai_launcher", - "kind": "requires", - "source_block": "MODULE_BUILD", - "source_id": "skill_lib_ai_launcher", - "to": "local bash + ssh; remote bash + tmux; optional remote grok/codex/deepcodei CLIs" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_legacy_shell_flag_maps_to_workspace/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_legacy_shell_flag_maps_to_workspace", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_legacy_shell_flag_maps_to_workspace", + "decorators": [], + "kind": "method", + "name": "test_legacy_shell_flag_maps_to_workspace", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_legacy_shell_flag_maps_to_workspace", + "signature": "def test_legacy_shell_flag_maps_to_workspace(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 131, + "span": { + "end": { + "byte": 4045, + "column": 53, + "line": 131 + }, + "start": { + "byte": 3808, + "column": 4, + "line": 128 + } + }, + "start_line": 128 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_legacy_shell_flag_maps_to_workspace", + "identity": "VmMcpPolicyTests.test_legacy_shell_flag_maps_to_workspace", + "scope": "symbol" + } }, { - "from": "vm_mcp_admin_client", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "vm_mcp_admin_client", - "to": "skill-lib vm-mcp maintainers" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_listing_does_not_follow_symlink_metadata/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_listing_does_not_follow_symlink_metadata", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_listing_does_not_follow_symlink_metadata", + "decorators": [], + "kind": "method", + "name": "test_listing_does_not_follow_symlink_metadata", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_listing_does_not_follow_symlink_metadata", + "signature": "def test_listing_does_not_follow_symlink_metadata(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 164, + "span": { + "end": { + "byte": 5477, + "column": 27, + "line": 164 + }, + "start": { + "byte": 4759, + "column": 4, + "line": 149 + } + }, + "start_line": 149 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_listing_does_not_follow_symlink_metadata", + "identity": "VmMcpPolicyTests.test_listing_does_not_follow_symlink_metadata", + "scope": "symbol" + } }, { - "from": "vm_mcp_control_plane", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "vm_mcp_control_plane", - "to": "skill-lib vm-mcp maintainers" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_parent_escape_rejected/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_parent_escape_rejected", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_parent_escape_rejected", + "decorators": [], + "kind": "method", + "name": "test_parent_escape_rejected", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_parent_escape_rejected", + "signature": "def test_parent_escape_rejected(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 135, + "span": { + "end": { + "byte": 4220, + "column": 73, + "line": 135 + }, + "start": { + "byte": 4051, + "column": 4, + "line": 133 + } + }, + "start_line": 133 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_parent_escape_rejected", + "identity": "VmMcpPolicyTests.test_parent_escape_rejected", + "scope": "symbol" + } }, { - "from": "vm_mcp_personal_console_broker", - "kind": "owns", - "source_block": "MODULE_BUILD", - "source_id": "vm_mcp_personal_console_broker", - "to": "skill-lib vm-mcp maintainers" + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_read_text_is_bounded/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_read_text_is_bounded", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_read_text_is_bounded", + "decorators": [], + "kind": "method", + "name": "test_read_text_is_bounded", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_read_text_is_bounded", + "signature": "def test_read_text_is_bounded(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 170, + "span": { + "end": { + "byte": 5767, + "column": 44, + "line": 170 + }, + "start": { + "byte": 5483, + "column": 4, + "line": 166 + } + }, + "start_line": 166 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_read_text_is_bounded", + "identity": "VmMcpPolicyTests.test_read_text_is_bounded", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_shell_cwd_escape_rejected/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_shell_cwd_escape_rejected", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_shell_cwd_escape_rejected", + "decorators": [], + "kind": "method", + "name": "test_shell_cwd_escape_rejected", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_shell_cwd_escape_rejected", + "signature": "def test_shell_cwd_escape_rejected(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 197, + "span": { + "end": { + "byte": 7023, + "column": 73, + "line": 197 + }, + "start": { + "byte": 6851, + "column": 4, + "line": 195 + } + }, + "start_line": 195 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_shell_cwd_escape_rejected", + "identity": "VmMcpPolicyTests.test_shell_cwd_escape_rejected", + "scope": "symbol" + } } ], + [ + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_shell_does_not_inherit_unrelated_environment/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_shell_does_not_inherit_unrelated_environment", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_shell_does_not_inherit_unrelated_environment", + "decorators": [], + "kind": "method", + "name": "test_shell_does_not_inherit_unrelated_environment", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_shell_does_not_inherit_unrelated_environment", + "signature": "def test_shell_does_not_inherit_unrelated_environment(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 223, + "span": { + "end": { + "byte": 8134, + "column": 51, + "line": 223 + }, + "start": { + "byte": 7759, + "column": 4, + "line": 217 + } + }, + "start_line": 217 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_shell_does_not_inherit_unrelated_environment", + "identity": "VmMcpPolicyTests.test_shell_does_not_inherit_unrelated_environment", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_shell_is_disabled_in_read_only/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_shell_is_disabled_in_read_only", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_shell_is_disabled_in_read_only", + "decorators": [], + "kind": "method", + "name": "test_shell_is_disabled_in_read_only", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_shell_is_disabled_in_read_only", + "signature": "def test_shell_is_disabled_in_read_only(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 193, + "span": { + "end": { + "byte": 6845, + "column": 44, + "line": 193 + }, + "start": { + "byte": 6697, + "column": 4, + "line": 191 + } + }, + "start_line": 191 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_shell_is_disabled_in_read_only", + "identity": "VmMcpPolicyTests.test_shell_is_disabled_in_read_only", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_shell_output_is_bounded_while_draining/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_shell_output_is_bounded_while_draining", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_shell_output_is_bounded_while_draining", + "decorators": [], + "kind": "method", + "name": "test_shell_output_is_bounded_while_draining", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_shell_output_is_bounded_while_draining", + "signature": "def test_shell_output_is_bounded_while_draining(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 206, + "span": { + "end": { + "byte": 7399, + "column": 51, + "line": 206 + }, + "start": { + "byte": 7029, + "column": 4, + "line": 199 + } + }, + "start_line": 199 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_shell_output_is_bounded_while_draining", + "identity": "VmMcpPolicyTests.test_shell_output_is_bounded_while_draining", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_shell_timeout_is_enforced/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_shell_timeout_is_enforced", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_shell_timeout_is_enforced", + "decorators": [], + "kind": "method", + "name": "test_shell_timeout_is_enforced", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_shell_timeout_is_enforced", + "signature": "def test_shell_timeout_is_enforced(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 215, + "span": { + "end": { + "byte": 7753, + "column": 56, + "line": 215 + }, + "start": { + "byte": 7405, + "column": 4, + "line": 208 + } + }, + "start_line": 208 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_shell_timeout_is_enforced", + "identity": "VmMcpPolicyTests.test_shell_timeout_is_enforced", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_symlink_escape_rejected/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_symlink_escape_rejected", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_symlink_escape_rejected", + "decorators": [], + "kind": "method", + "name": "test_symlink_escape_rejected", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_symlink_escape_rejected", + "signature": "def test_symlink_escape_rejected(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 147, + "span": { + "end": { + "byte": 4753, + "column": 27, + "line": 147 + }, + "start": { + "byte": 4226, + "column": 4, + "line": 137 + } + }, + "start_line": 137 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_symlink_escape_rejected", + "identity": "VmMcpPolicyTests.test_symlink_escape_rejected", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_write_and_move_remain_under_root/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_write_and_move_remain_under_root", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_write_and_move_remain_under_root", + "decorators": [], + "kind": "method", + "name": "test_write_and_move_remain_under_root", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_write_and_move_remain_under_root", + "signature": "def test_write_and_move_remain_under_root(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 189, + "span": { + "end": { + "byte": 6691, + "column": 54, + "line": 189 + }, + "start": { + "byte": 6263, + "column": 4, + "line": 183 + } + }, + "start_line": 183 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_write_and_move_remain_under_root", + "identity": "VmMcpPolicyTests.test_write_and_move_remain_under_root", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_write_requires_mutating_profile/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "callable-declaration", + "native": { + "id": "VmMcpPolicyTests.test_write_requires_mutating_profile", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::method:VmMcpPolicyTests.test_write_requires_mutating_profile", + "decorators": [], + "kind": "method", + "name": "test_write_requires_mutating_profile", + "parent_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "qualified_name": "VmMcpPolicyTests.test_write_requires_mutating_profile", + "signature": "def test_write_requires_mutating_profile(self) -> None" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 181, + "span": { + "end": { + "byte": 6257, + "column": 51, + "line": 181 + }, + "start": { + "byte": 6101, + "column": 4, + "line": 179 + } + }, + "start_line": 179 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests.test_write_requires_mutating_profile", + "identity": "VmMcpPolicyTests.test_write_requires_mutating_profile", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests/fact/declaration", + "convention": { + "dialect": "python", + "namespace": "python.source-metadata", + "version": "Python 3.13" + }, + "extraction": { + "configuration_sha256": "45ea84c96bf193e05d67adb298ecc098b45c05a9e59f0851e9b007638a16eef3", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "python-ast", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "class-declaration", + "native": { + "id": "VmMcpPolicyTests", + "value": { + "attachment_identity": "python:The-Interdependency/skill-lib:vm-mcp/tests/test_policy.py::class:VmMcpPolicyTests", + "decorators": [], + "kind": "class", + "name": "VmMcpPolicyTests", + "parent_identity": null, + "qualified_name": "VmMcpPolicyTests", + "signature": "class VmMcpPolicyTests(unittest.TestCase)" + } + }, + "origin": "native", + "projection": { + "canonical_field": "declared_surface", + "loss": "behavior not inferred", + "mapping_version": "python-surfaces@2" + }, + "source": { + "content_sha256": "288471b8b340342804cbe66164e506189021e8b47a0b35037b689c796d6cb9a3", + "file": "vm-mcp/tests/test_policy.py", + "location": { + "end_line": 230, + "span": { + "end": { + "byte": 8424, + "column": 13, + "line": 230 + }, + "start": { + "byte": 2832, + "column": 0, + "line": 101 + } + }, + "start_line": 101 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "syntactically-observed", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/vm-mcp/tests/test_policy.py#subject/symbol/VmMcpPolicyTests", + "identity": "VmMcpPolicyTests", + "scope": "symbol" + } + }, + { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/website-builder-journal/SKILL.md#subject/document/website-builder-journal%2FSKILL.md/fact/frontmatter/lines%3A1-4", + "convention": { + "dialect": "yaml-frontmatter", + "namespace": "markdown.yaml-frontmatter", + "version": "YAML 1.2 core" + }, + "extraction": { + "configuration_sha256": "82fda798849b9b208b1d2788032320f281bbfdf5b06d9bb2b072cac9db13059e", + "implementation_sha256": "74cb9ce14d00f6d097c28fb9cfb494b06c0a49e9fd9c1bc70a8fa507df430a42", + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "support": "implemented-and-tested" + }, + "kind": "frontmatter", + "native": { + "id": null, + "value": { + "fields": { + "description": "Load this when any modification to The-Interdependency/The-Interdependency.github.io is planned or underway, including source, content, configuration, tests, workflows, dependencies, generated-contract code, or deployment paths. Every website change transaction must append at least one By the builder entry recording date, time, and the exact runtime model; the model chooses the subject and writes no more than needed to explicate it. Do not load for read-only inspection that changes no website file.", + "name": "website-builder-journal" + }, + "generated": false, + "raw_source": "source-reference" + } + }, + "origin": "native", + "source": { + "content_sha256": "e0cf8442a8f6a9f8aa9dcb7c811f8f726bfb24029944069d8a2b54cf3ce2c97b", + "file": "website-builder-journal/SKILL.md", + "location": { + "end_line": 4, + "start_line": 1 + }, + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690" + }, + "standing": "declared", + "subject": { + "address": "msdmd://The-Interdependency%2Fskill-lib@snapshot%3A3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690/website-builder-journal/SKILL.md#subject/document/website-builder-journal%2FSKILL.md", + "identity": "website-builder-journal/SKILL.md", + "scope": "document" + } + } + ] + ), "gaps": [], - "repo": "The-Interdependency/skill-lib" + "reader_manifests": [ + { + "convention": "python.source-metadata", + "dependencies": [ + "python-stdlib:ast", + "python-stdlib:tokenize", + "docstring-parser==0.18.0" + ], + "detection": [ + ".py", + ".pyi", + ".pyw" + ], + "entry_point": "msdmd.readers:_read_python", + "execution_policy": "parse only; never import or evaluate", + "feature_subset": [ + "qualified symbols and signatures", + "AST/token comment attachment shared with module_projection", + "ReST/Google/NumPy docstring fields", + "lexically scoped imports", + "literal __all__" + ], + "known_limitations": [ + "runtime effects and dynamic imports/exports are not executed" + ], + "reader_id": "python-ast", + "scope_attachment": "module and qualified symbol", + "specification": "https://docs.python.org/3/reference/", + "support": "implemented-and-tested", + "supported_versions": [ + "Python 3 syntax accepted by the running ast parser" + ], + "unknown_field_policy": "preserve source expression or emit dynamic-unresolved diagnostic", + "version": "2.0.0" + }, + { + "convention": "msdmd.ratios-line", + "dependencies": [ + "msdmd.parsers.universal" + ], + "detection": [ + "supported line-comment source containing ratios:" + ], + "entry_point": "msdmd.readers:_read_ratios", + "execution_policy": "text parse only; never run ratio computers", + "feature_subset": [ + "opening/closing placement", + "named ratio/value preservation" + ], + "reader_id": "msdmd-ratios", + "scope_attachment": "file boundary occurrence", + "specification": "The-Interdependency/skill-lib ratios/SKILL.md", + "support": "implemented-and-tested", + "supported_versions": [ + "named ratios line v1" + ], + "unknown_field_policy": "preserve hmmm as an explicit value", + "version": "1.0.0" + }, + { + "convention": "json.document", + "dependencies": [ + "python-stdlib:json" + ], + "detection": [ + ".json" + ], + "entry_point": "msdmd.readers:_read_json", + "execution_policy": "parse only; no reference resolution", + "feature_subset": [ + "complete typed document tree", + "package.json dependency classes" + ], + "reader_id": "json-stdlib", + "scope_attachment": "document and JSON Pointer", + "specification": "RFC 8259", + "support": "implemented-and-tested", + "supported_versions": [ + "RFC 8259 JSON" + ], + "unknown_field_policy": "preserve in typed document tree", + "version": "1.0.0" + }, + { + "convention": "toml.document", + "dependencies": [ + "python-stdlib:tomllib" + ], + "detection": [ + ".toml" + ], + "entry_point": "msdmd.readers:_read_toml", + "execution_policy": "parse only; never invoke build backends", + "feature_subset": [ + "complete typed document tree", + "pyproject project/build dependency classes" + ], + "reader_id": "toml-stdlib", + "scope_attachment": "document and TOML key path", + "specification": "TOML 1.0.0 and Python packaging metadata specifications", + "support": "implemented-and-tested", + "supported_versions": [ + "TOML accepted by the running tomllib parser" + ], + "unknown_field_policy": "preserve in typed document tree", + "version": "1.0.0" + }, + { + "convention": "markdown.yaml-frontmatter", + "dependencies": [ + "PyYAML==6.0.3" + ], + "detection": [ + ".md", + ".mdx" + ], + "entry_point": "msdmd.readers:_read_markdown", + "execution_policy": "text parse only; never execute MDX", + "feature_subset": [ + "nested frontmatter and typed values", + "safe acyclic aliases", + "multiline scalars" + ], + "reader_id": "markdown-frontmatter", + "scope_attachment": "document", + "specification": "https://yaml.org/spec/1.2.2/", + "support": "implemented-and-tested", + "supported_versions": [ + "YAML 1.2 core scalar subset with typed scalar-key preservation" + ], + "unknown_field_policy": "preserve typed tree; reject duplicate keys, custom tags, cyclic aliases and merge dialects", + "version": "2.0.0" + }, + { + "convention": "yaml.core", + "dependencies": [ + "PyYAML==6.0.3" + ], + "detection": [ + ".yml", + ".yaml" + ], + "entry_point": "msdmd.readers:_read_yaml", + "execution_policy": "text parse only; no tags, templates, actions, or includes", + "feature_subset": [ + "typed nested mappings/sequences", + "flow syntax", + "acyclic aliases", + "multiline scalars" + ], + "known_limitations": [ + "custom tags, merge keys and cyclic aliases rejected; keys retain lexical strings" + ], + "reader_id": "yaml-core", + "scope_attachment": "document and structural path", + "specification": "https://yaml.org/spec/1.2.2/", + "support": "implemented-and-tested", + "supported_versions": [ + "YAML 1.2 core with typed scalar-key preservation" + ], + "unknown_field_policy": "diagnose unsupported syntax; preserve raw source by digest", + "version": "2.0.0" + }, + { + "convention": "typescript.source-metadata", + "dependencies": [ + "Node.js", + "typescript==5.8.3" + ], + "detection": [ + ".js", + ".jsx", + ".mjs", + ".cjs", + ".ts", + ".tsx", + ".mts", + ".cts" + ], + "entry_point": "msdmd.readers:_read_typescript", + "execution_policy": "trusted parser worker only; inspected code never executed", + "feature_subset": [ + "syntax-tree symbol ownership", + "multiline signatures", + "imports and reexports", + "compiler JSDoc tags with unknown tag text preserved" + ], + "known_limitations": [ + "not a TSDoc validator", + "no type checking, config loading, import resolution or target execution" + ], + "reader_id": "typescript-compiler", + "scope_attachment": "compiler AST module/symbol", + "specification": "https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html", + "support": "implemented-and-tested", + "supported_versions": [ + "TypeScript 5.8.3 parser accepting JS/JSX/TS/TSX/MJS/MTS/CTS/CJS" + ], + "unknown_field_policy": "retain raw documentation tags and report parse diagnostics", + "version": "2.0.0" + }, + { + "convention": "github.codeowners", + "dependencies": [], + "detection": [ + "CODEOWNERS", + ".github/CODEOWNERS", + "docs/CODEOWNERS" + ], + "entry_point": "msdmd.readers:_read_codeowners", + "execution_policy": "text parse only", + "feature_subset": [ + "ordered pattern and owner extraction" + ], + "reader_id": "github-codeowners", + "scope_attachment": "ordered path rule", + "specification": "https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners", + "support": "implemented-and-tested", + "supported_versions": [ + "GitHub CODEOWNERS line grammar" + ], + "unknown_field_policy": "diagnose malformed rules; do not infer operational ownership", + "version": "1.0.0" + }, + { + "convention": "shell.source-metadata", + "dependencies": [], + "detection": [ + ".sh", + ".bash", + ".zsh", + ".fish", + "extensionless shebang scripts" + ], + "entry_point": "msdmd.readers:_read_shell", + "execution_policy": "text parse only; never source or execute", + "feature_subset": [ + "shebang", + "ShellCheck directives" + ], + "reader_id": "shell-static", + "scope_attachment": "file", + "specification": "POSIX shebang convention and ShellCheck directives", + "support": "implemented-and-tested", + "supported_versions": [ + "declaration extraction only" + ], + "unknown_field_policy": "preserve directive text", + "version": "1.0.0" + }, + { + "convention": "systemd.unit", + "dependencies": [], + "detection": [ + ".service", + ".socket", + ".timer", + ".path", + ".target" + ], + "entry_point": "msdmd.readers:_read_systemd", + "execution_policy": "text parse only; never invoke systemd", + "feature_subset": [ + "ordered sections", + "repeated directives", + "continuation lines" + ], + "reader_id": "systemd-unit", + "scope_attachment": "unit section and directive occurrence", + "specification": "https://www.freedesktop.org/software/systemd/man/latest/systemd.syntax.html", + "support": "implemented-and-tested", + "supported_versions": [ + "section/key/value declaration extraction" + ], + "unknown_field_policy": "preserve key/value and order without interpreting runtime effect", + "version": "1.0.0" + }, + { + "convention": "git.ignore", + "dependencies": [], + "detection": [ + ".gitignore" + ], + "entry_point": "msdmd.readers:_read_gitignore", + "execution_policy": "text parse only; never invoke Git matching", + "feature_subset": [ + "pattern order", + "negation", + "anchoring", + "directory-only flag" + ], + "reader_id": "gitignore-lines", + "scope_attachment": "repository path rule", + "specification": "https://git-scm.com/docs/gitignore", + "support": "implemented-and-tested", + "supported_versions": [ + "ordered pattern declarations" + ], + "unknown_field_policy": "preserve pattern text without evaluating matches", + "version": "1.0.0" + }, + { + "convention": "python.requirements-file", + "dependencies": [], + "detection": [ + "requirements*.txt", + "constraints*.txt" + ], + "entry_point": "msdmd.readers:_read_requirements", + "execution_policy": "text parse only; never install or resolve packages", + "feature_subset": [ + "requirement text", + "package name", + "options", + "ordered source lines" + ], + "known_limitations": [ + "does not resolve includes, environment markers, URLs, or indexes" + ], + "reader_id": "python-requirements", + "scope_attachment": "requirements document line", + "specification": "PyPA requirements file format", + "support": "partial", + "supported_versions": [ + "one-line requirement and option subset" + ], + "unknown_field_policy": "preserve text and redact URL credentials", + "version": "1.0.0" + }, + { + "convention": "license.text", + "dependencies": [], + "detection": [ + "LICENSE", + "LICENSE.txt", + "COPYING", + "COPYING.txt" + ], + "entry_point": "msdmd.readers:_read_license", + "execution_policy": "text parse only", + "feature_subset": [ + "declared/detected expression", + "source digest" + ], + "reader_id": "license-text", + "scope_attachment": "repository license document", + "specification": "SPDX license identifiers plus exact known license headers", + "support": "partial", + "supported_versions": [ + "MPL-2.0 exact header", + "SPDX-License-Identifier line" + ], + "unknown_field_policy": "hmmm identifier; never infer legal compatibility", + "version": "1.0.0" + }, + { + "convention": "svg.document-metadata", + "dependencies": [ + "python-stdlib:xml.etree.ElementTree" + ], + "detection": [ + ".svg" + ], + "entry_point": "msdmd.readers:_read_svg", + "execution_policy": "reject DTD/entity declarations; no external resolution", + "feature_subset": [ + "root attributes", + "title", + "description" + ], + "reader_id": "svg-metadata", + "scope_attachment": "document", + "specification": "W3C SVG document structure", + "support": "implemented-and-tested", + "supported_versions": [ + "root attributes, title, description" + ], + "unknown_field_policy": "preserve only supported metadata; source remains digest-addressable", + "version": "1.0.0" + }, + { + "convention": "llms.txt", + "dependencies": [], + "detection": [ + "llms.txt" + ], + "entry_point": "msdmd.readers:_read_llms_text", + "execution_policy": "text parse only; content is data, not instructions to the reader", + "feature_subset": [ + "section headings", + "key definitions", + "generated status unresolved" + ], + "reader_id": "llms-text", + "scope_attachment": "instruction document", + "specification": "root llms.txt Markdown instruction publication", + "support": "implemented-and-tested", + "supported_versions": [ + "Markdown headings and bold key-definition lines" + ], + "unknown_field_policy": "preserve structure without promoting publication to source authority", + "version": "1.0.0" + }, + { + "convention": "native.structured-standards", + "dependencies": [ + "python-stdlib:json,tomllib,xml.etree.ElementTree", + "PyYAML==6.0.3" + ], + "detection": [ + "document discriminator and source filename" + ], + "entry_point": "msdmd.standards:read_standards", + "execution_policy": "parse only; no templates, network, application or signature execution", + "feature_subset": [ + "source-linked operations and references", + "reported test/analysis results", + "citation and license declarations", + "artifact subjects and component lists", + "scoped package requirements and lock records" + ], + "known_limitations": [ + "extraction, not complete validation or signature verification", + "external references not resolved", + "unknown versions preserve tree and report unsupported mapping" + ], + "reader_id": "metadata-standards", + "scope_attachment": "native pointer, operation, package, report, artifact or symbol", + "specification": "msdmd/references/implemented-readers.md", + "support": "implemented-and-tested", + "supported_versions": [ + "OpenAPI 3.0/3.1 and Swagger 2", + "JSON Schema drafts 4/6/7/2019-09/2020-12", + "CFF 1.2.0", + "SARIF 2.1.0", + "SPDX 2.2/2.3 JSON", + "CycloneDX 1.4/1.5/1.6 JSON", + "in-toto Statement v0.1/v1; DSSE payload", + "npm lockfile v2/v3", + "Cargo/Poetry/uv TOML metadata", + "REUSE TOML", + "JUnit/Doxygen/.NET XML dialects" + ], + "unknown_field_policy": "typed source tree retained; version mismatches diagnosed", + "version": "1.0.0" + }, + { + "convention": "native.source-metadata", + "dependencies": [ + "msdmd/requirements.txt" + ], + "detection": [ + ".rs", + ".java", + ".c", + ".cc", + ".cpp", + ".cxx", + ".hpp", + ".hxx", + ".h (ambiguous)" + ], + "entry_point": "msdmd.grammar_code:read_grammar", + "execution_policy": "parse only; no compiler, macro expansion or annotation processing", + "feature_subset": [ + "named declarations", + "Rustdoc/Javadoc/Doxygen raw docs and repeated tags", + "imports", + "attributes", + "SPDX headers" + ], + "reader_id": "native-grammars", + "scope_attachment": "lexical symbols and adjacent documentation", + "specification": "pinned tree-sitter language grammars", + "support": "partial", + "supported_versions": [ + "Rust grammar 0.24.2", + "Java grammar 0.23.5", + "C grammar 0.24.2", + "C++ grammar 0.23.4" + ], + "unknown_field_policy": "preserve raw documentation and syntax; diagnose macro/conditional context", + "version": "1.0.0" + } + ], + "reader_runs": [ + { + "facts_emitted": 1993, + "files_matched": 83, + "reader_id": "python-ast", + "reader_version": "2.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 276, + "files_matched": 53, + "reader_id": "msdmd-ratios", + "reader_version": "1.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 15, + "files_matched": 18, + "reader_id": "json-stdlib", + "reader_version": "1.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 0, + "files_matched": 0, + "reader_id": "toml-stdlib", + "reader_version": "1.0.0", + "status": "not-applicable", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 86, + "files_matched": 110, + "reader_id": "markdown-frontmatter", + "reader_version": "2.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 4, + "files_matched": 4, + "reader_id": "yaml-core", + "reader_version": "2.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 335, + "files_matched": 3, + "reader_id": "typescript-compiler", + "reader_version": "2.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 0, + "files_matched": 0, + "reader_id": "github-codeowners", + "reader_version": "1.0.0", + "status": "not-applicable", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 3, + "files_matched": 4, + "reader_id": "shell-static", + "reader_version": "1.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 62, + "files_matched": 2, + "reader_id": "systemd-unit", + "reader_version": "1.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 9, + "files_matched": 1, + "reader_id": "gitignore-lines", + "reader_version": "1.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 8, + "files_matched": 2, + "reader_id": "python-requirements", + "reader_version": "1.0.0", + "status": "applied", + "support": "partial" + }, + { + "facts_emitted": 2, + "files_matched": 2, + "reader_id": "license-text", + "reader_version": "1.0.0", + "status": "applied", + "support": "partial" + }, + { + "facts_emitted": 1, + "files_matched": 1, + "reader_id": "svg-metadata", + "reader_version": "1.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 8, + "files_matched": 1, + "reader_id": "llms-text", + "reader_version": "1.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 23, + "files_matched": 22, + "reader_id": "metadata-standards", + "reader_version": "1.0.0", + "status": "applied", + "support": "implemented-and-tested" + }, + { + "facts_emitted": 0, + "files_matched": 0, + "reader_id": "native-grammars", + "reader_version": "1.0.0", + "status": "not-applicable", + "support": "partial" + } + ], + "repo": "The-Interdependency/skill-lib", + "requirements": [], + "schema": "the-interdependency.msdmd-collection", + "schema_version": "2.0.0", + "source": { + "dirty_worktree": "hmmm", + "exclusion_accounting": "configured-patterns", + "git_head": "hmmm", + "repository": "The-Interdependency/skill-lib", + "revision": "snapshot:3a450447ca9a4083c90d2e90c8f7e142420ca01a0c73d8ae32ce43a45148c690", + "revision_kind": "content-snapshot", + "scope": "configured in-scope files; excluded subtrees are reported without traversing", + "snapshot_complete": true, + "snapshot_sha256": "c1b47c78a31b9a70bc5d44b5e980705a84f00f9b2a7faab179d965cdce263656" + } }); diff --git a/skills.json b/skills.json index 1ae77b5..dc48f66 100644 --- a/skills.json +++ b/skills.json @@ -10,7 +10,7 @@ } ], "skills": [ - {"name":"msdmd","path":"msdmd/SKILL.md","kind":"metadata-block","status":"runnable","description":"Module Self-Declared Metadata in Markdown — native-first collection of metadata already expressed by code, documentation, manifests, schemas, tooling, and evidence formats, with MSDMD blocks only for otherwise unexpressed information. Load this when creating or revising metadata-driven skills, collecting repository metadata, integrating a metadata convention, building parsers or collection consumers, or auditing metadata coverage and provenance.","runner":"msdmd/collect.py","runner_scope":"msdmd-blocks-only","native_ingestion":{"status":"partial","runner":"msdmd/module_projection.py","scope":"python-symbol-signature-docstring-comment-projection","schema":"msdmd/module-projection.schema.json","manifest":"msdmd/python-module-reader.json"}}, + {"name":"msdmd","path":"msdmd/SKILL.md","kind":"metadata-block","status":"runnable","description":"Module Self-Declared Metadata in Markdown — native-first collection of metadata already expressed by code, documentation, manifests, schemas, tooling, and evidence formats, with MSDMD blocks only for otherwise unexpressed information. Load this when creating or revising metadata-driven skills, collecting repository metadata, integrating a metadata convention, building parsers or collection consumers, or auditing metadata coverage and provenance.","runner":"msdmd/collect.py","runner_scope":"native-and-supplemental","native_ingestion":{"status":"implemented-subsets","runner":"msdmd/collect.py","scope":"fixture-backed native source and structured-standard extraction","schema":"msdmd/collection.ts","manifest":"msdmd/readers.py"}}, {"name":"doc-build","path":"doc-build/SKILL.md","kind":"metadata-block","depends_on":["msdmd"],"description":"Native-first documentation coverage built on msdmd. Consume docstrings, documentation comments and source-linked documents; supplemental DOCS blocks express remaining obligations. A consuming runner verifies references and reports missing information separately from unsupported extraction. Load this when adding or auditing module documentation, tying code surfaces to docs, or wiring documentation coverage checks into CI."}, {"name":"cap-build","path":"cap-build/SKILL.md","kind":"metadata-block","depends_on":["msdmd"],"description":"Native-first capability inventory built on msdmd. Consume signatures, exports, annotations and API schemas; supplemental CAPABILITIES blocks express otherwise unrecorded behavior and boundaries. Keep declared surfaces separate from verified behavior. Load this when declaring module capabilities, building capability registries for agents, or auditing exposed surfaces against declared capabilities."}, {"name":"deps-build","path":"deps-build/SKILL.md","kind":"metadata-block","depends_on":["msdmd"],"description":"Native-first dependency topology built on msdmd. Consume imports, package manifests, lockfiles and build declarations at their owning scopes; supplemental DEPENDENCIES blocks express remaining architectural intent. Preserve edge kinds, conditions and resolution uncertainty. Load this when declaring dependencies, auditing architecture drift, checking graph cycles, or wiring dependency topology checks into CI."}, @@ -25,7 +25,7 @@ {"name":"llms-build","path":"llms-build/SKILL.md","kind":"metadata-block","depends_on":["msdmd"],"description":"Native-first LLM instruction publication built on msdmd. Consume source-owned instruction metadata without requiring a second copy; the shipped stdlib runner generates llms.txt from LLMS blocks, while native-reader integration remains a contract. Load this when creating, updating, or maintaining llms.txt for repositories consumed by LLMs or agents."}, {"name":"char-compress","path":"char-compress/SKILL.md","kind":"procedural","description":"Character-based context compression for agent handoff and skill writing, owned as a skill-lib procedure rather than current UCNS mathematics. Use this when compressing a long thread, document, repo audit, canon handoff, or agent working-memory state; when a context window is filling and operative facts must survive; when writing a SKILL.md that should be flesh-dense and bone-sparse; or when checking whether a compression deleted negation, order, quantifier, operator, named object, value, decision, or unresolved hmmm. Historical bone/flesh and text-stack terminology is local compression notation, not a UCNS theorem/status transfer, active language-construction authority, or edcmbone metric implementation."}, {"name":"visitor-intro","path":"visitor-intro/SKILL.md","kind":"procedural","description":"Onboarding tour for visitors arriving at any The-Interdependency repo. Load this when an unfamiliar user asks \"what is this?\", \"what is The Interdependency?\", \"how do these repos fit together?\", \"where do I start?\", or otherwise signals they are new to the org. Gives the agent a consistent, repo-aware way to orient a newcomer without inventing facts."}, - {"name":"agent-instantiation","path":"agent-instantiation/SKILL.md","kind":"procedural","description":"Methodology for instantiating, forking, running, merging, and retiring agents in the a0 platform and its near-identical mirror a0ucns. Load this when adding or changing a sub-agent spawn path, a PCNA instance fork/merge, an agent definition or naming scheme, spawn caps or approval gating, an agent run/log table, a heartbeat-driven agent task, or a checkpoint of agent state. Use it before writing any code that creates, addresses, schedules, or tears down an agent or sub-agent, so the new code follows the platform's existing lifecycle, fork/merge, identity, and gating contracts rather than inventing a parallel one. NOTE: a0-betatest (a0p) has diverged to a different per-user CRUD + native-ZFAE instancing model — this skill's spawn/fork/merge sequence does NOT apply there; see \"a0-betatest divergence\"."}, + {"name":"agent-instantiation","path":"agent-instantiation/SKILL.md","kind":"procedural","description":"Methodology for instantiating, forking, running, merging, and retiring agents in the a0 platform and its near-identical mirror a0ucns. Load this when adding or changing a sub-agent spawn path, a PCNA instance fork/merge, an agent definition or naming scheme, spawn caps or approval gating, an agent run/log table, a heartbeat-driven agent task, or a checkpoint of agent state. Use it before writing any code that creates, addresses, schedules, or tears down an agent or sub-agent, so the new code follows the platform's existing lifecycle, fork/merge, identity, and gating contracts rather than inventing a parallel one. NOTE — a0-betatest (a0p) has diverged to a different per-user CRUD + native-ZFAE instancing model — this skill's spawn/fork/merge sequence does NOT apply there; see \"a0-betatest divergence\"."}, {"name":"a0p-instancing","path":"a0p-instancing/SKILL.md","kind":"procedural","description":"Methodology for instancing agents in a0-betatest (the a0p research instrument), whose model diverges from canonical a0. Load this when adding or changing an AgentInstance / CharacterSheet CRUD path, a per-instance native ZFAE weight bank or its training/distillation loop, a ZFAE inference mode, a sentinel evaluation or pending-override gate, a per-agent safetensors checkpoint, or volatile sub-context memory — anywhere under a0-betatest `backend/`. Use it before writing code that creates, addresses, trains, runs, governs, or persists an a0p agent, so the code follows a0p's per-user CRUD + native-ZFAE + sentinel model instead of a0's spawn/fork/merge model. For canonical a0 and its mirror a0ucns, use `agent-instantiation` instead — a0p does NOT have `sub_agent_spawn`, a spawn executor, or `InstanceMerge`."}, {"name":"plain-lens","path":"plain-lens/SKILL.md","kind":"procedural","description":"Building a plain-language, multi-lens companion view of dense canonical text — an easier on-ramp that does not replace or talk down to the source. Load this when you are asked to make an informationally dense document (canon, spec, articles, legal/normative text) easier to approach for newcomers; when building an \"explain it through the lens of X\" selector (domain, audience, or role); when designing progressive-disclosure or layered ELI-not-stupid reading UX; when a dynamic, data-driven site must keep its existing static page as a graceful fallback; or when you need an EDCM-style two-speaker tension reading between a body text and its footnotes/caveats. Use this when the risk is either drowning readers in density or insulting them with oversimplification."}, {"name":"thought-lens","path":"thought-lens/SKILL.md","kind":"procedural","description":"Translate raw, context-heavy, recursive, fragmentary, coined, or private-language thought into audience-legible language without changing the underlying claim. Load this when a user says people do not understand what they mean; asks to make a thought understandable to strangers, the public, a specific audience, or a platform; supplies dense notes rather than finished prose; needs jargon or coined terms introduced only after their ordinary-language meaning lands; or wants multiple audience/surface renderings from one thought. Do not load merely to polish finished prose or to simplify an already-stable canonical document; use ordinary editing for the former and plain-lens for the latter."}, diff --git a/skills/agent-instantiation/SKILL.md b/skills/agent-instantiation/SKILL.md index 76a762c..7478bd7 100644 --- a/skills/agent-instantiation/SKILL.md +++ b/skills/agent-instantiation/SKILL.md @@ -1,6 +1,6 @@ --- name: agent-instantiation -description: "Methodology for instantiating, forking, running, merging, and retiring agents in the a0 platform and its near-identical mirror a0ucns. Load this when adding or changing a sub-agent spawn path, a PCNA instance fork/merge, an agent definition or naming scheme, spawn caps or approval gating, an agent run/log table, a heartbeat-driven agent task, or a checkpoint of agent state. Use it before writing any code that creates, addresses, schedules, or tears down an agent or sub-agent, so the new code follows the platform's existing lifecycle, fork/merge, identity, and gating contracts rather than inventing a parallel one. NOTE: a0-betatest (a0p) has diverged to a different per-user CRUD + native-ZFAE instancing model — this skill's spawn/fork/merge sequence does NOT apply there; see \"a0-betatest divergence\"." +description: "Methodology for instantiating, forking, running, merging, and retiring agents in the a0 platform and its near-identical mirror a0ucns. Load this when adding or changing a sub-agent spawn path, a PCNA instance fork/merge, an agent definition or naming scheme, spawn caps or approval gating, an agent run/log table, a heartbeat-driven agent task, or a checkpoint of agent state. Use it before writing any code that creates, addresses, schedules, or tears down an agent or sub-agent, so the new code follows the platform's existing lifecycle, fork/merge, identity, and gating contracts rather than inventing a parallel one. NOTE — a0-betatest (a0p) has diverged to a different per-user CRUD + native-ZFAE instancing model — this skill's spawn/fork/merge sequence does NOT apply there; see \"a0-betatest divergence\"." --- <!-- Generated by tools/build_codex_plugin_skills.py; do not edit. --> diff --git a/tests/test_collect.py b/tests/test_collect.py index ca5d612..426c73c 100644 --- a/tests/test_collect.py +++ b/tests/test_collect.py @@ -5,7 +5,7 @@ import unittest from pathlib import Path -from msdmd.collect import collect, render_typescript +from msdmd.collect import SCHEMA_VERSION, collect, collect_legacy, render_typescript class CollectTest(unittest.TestCase): @@ -51,84 +51,52 @@ def test_collect_emits_declarations_gaps_and_edges(self) -> None: ) self.assertEqual("sample", collection["repo"]) - self.assertEqual("abc123", collection["source_commit"]) + self.assertEqual(SCHEMA_VERSION, collection["schema_version"]) + self.assertEqual("abc123", collection["source"]["revision"]) self.assertEqual( [ - { - "file": "module.py", - "block": "DEPENDENCIES", - "id": "module_edges", - "fields": { - "summary": "module depends on another module", - "requires": "other_module", - }, - }, - { - "file": "module.py", - "block": "DOCS", - "id": "module_docs", - "fields": { - "summary": "module docs", - "source": "docs/module.md", - "status": "current", - }, - }, - { - "file": "test_module.py", - "block": "CHECKS", - "id": "check_module_edges", - "fields": { - "proves": "module_contract", - "call": "self::test_module_edges", - }, - }, + ("module.py", "DEPENDENCIES", "module_edges"), + ("module.py", "DOCS", "module_docs"), + ("test_module.py", "CHECKS", "check_module_edges"), ], - collection["declarations"], + [(item["file"], item["block"], item["id"]) for item in collection["declarations"]], ) + self.assertTrue(all(item["address"].startswith("msdmd://sample@abc123/") for item in collection["declarations"])) self.assertEqual( [ - {"file": "gap.py", "missing": ["DOCS"]}, - {"file": "test_module.py", "missing": ["DOCS"]}, + {"file": "gap.py", "missing": ["DOCS"], "kind": "block-adoption"}, + {"file": "test_module.py", "missing": ["DOCS"], "kind": "block-adoption"}, ], collection["gaps"], ) - self.assertEqual( - [ - { - "from": "check_module_edges", - "to": "self::test_module_edges", - "kind": "calls", - "source_block": "CHECKS", - "source_id": "check_module_edges", - }, - { - "from": "check_module_edges", - "to": "module_contract", - "kind": "claims_proves", - "source_block": "CHECKS", - "source_id": "check_module_edges", - }, - { - "from": "module_edges", - "to": "other_module", - "kind": "requires", - "source_block": "DEPENDENCIES", - "source_id": "module_edges", - }, - ], - collection["edges"], - ) + block_edges = [item for item in collection["edges"] if "source_block" in item] + self.assertEqual(["calls", "claims_proves", "requires"], sorted(item["kind"] for item in block_edges)) + self.assertTrue(all(item["from"].startswith("msdmd://sample@abc123/") for item in block_edges)) + self.assertTrue(all(item["source_id"] == item["from"] for item in block_edges)) def test_render_typescript_uses_collection_helper(self) -> None: rendered = render_typescript( - {"repo": "sample", "declarations": [], "gaps": [], "edges": []}, + {"schema_version": SCHEMA_VERSION, "repo": "sample", "declarations": [], "gaps": [], "edges": []}, import_path="./msdmd/collection", ) - self.assertIn('import { defineMsdmdCollection } from "./msdmd/collection";', rendered) - self.assertIn("export default defineMsdmdCollection", rendered) + self.assertIn('import { defineMsdmdCollectionV2 } from "./msdmd/collection";', rendered) + self.assertIn("export default defineMsdmdCollectionV2", rendered) self.assertIn('"repo": "sample"', rendered) + def test_collect_legacy_is_explicitly_block_only(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "module.py").write_text( + "# === DOCS ===\n# id: module_docs\n# summary: docs\n# === END DOCS ===\n", + encoding="utf-8", + ) + collection = collect_legacy(root, "sample", block_names=("DOCS",), source_commit="abc123") + + self.assertEqual("1.0.0", collection["schema_version"]) + self.assertNotIn("facts", collection) + self.assertEqual("abc123", collection["source_commit"]) + def test_collect_skips_vendored_agent_skills(self) -> None: with tempfile.TemporaryDirectory() as tmp: root = Path(tmp) diff --git a/tests/test_collection_schema.py b/tests/test_collection_schema.py index 6744ab2..e64752f 100644 --- a/tests/test_collection_schema.py +++ b/tests/test_collection_schema.py @@ -34,6 +34,11 @@ def test_collection_schema_exports_required_types(self) -> None: "MsdmdEdge", "MsdmdCollection", "defineMsdmdCollection", + "MsdmdCollectionV2", + "MsdmdNativeFact", + "MsdmdReaderManifest", + "MsdmdDiagnostic", + "defineMsdmdCollectionV2", ]: with self.subTest(exported=exported): self.assertIn(f"export ", self.source) @@ -55,7 +60,24 @@ def test_declaration_gap_and_edge_shapes_have_visualizer_fields(self) -> None: "kind: string", "source_block: MsdmdBlockName", "source_id: string", - "edges?: MsdmdEdge[]", + "edges?: MsdmdEdgeV1[]", + ]: + with self.subTest(field=field): + self.assertIn(field, self.source) + + def test_native_schema_requires_version_provenance_and_negotiation(self) -> None: + for field in [ + 'schema_version: "2.0.0"', + "address: string", + "source: MsdmdSourceReference", + "content_sha256: string", + "reader_manifests: MsdmdReaderManifest[]", + "facts: MsdmdNativeFact[]", + "discovery: MsdmdDiscoveryEntry[]", + "conflicts: MsdmdConflict[]", + "diagnostics: MsdmdDiagnostic[]", + "source_entry_id?: string", + "target_resolution:", ]: with self.subTest(field=field): self.assertIn(field, self.source) diff --git a/tests/test_msdmd_native_contract_docs.py b/tests/test_msdmd_native_contract_docs.py index db1655f..13fcbf3 100644 --- a/tests/test_msdmd_native_contract_docs.py +++ b/tests/test_msdmd_native_contract_docs.py @@ -74,42 +74,30 @@ def test_retired_block_absence_rules_are_removed(self) -> None: with self.subTest(skill=name, phrase=phrase): self.assertNotIn(phrase, text) - def test_block_runner_and_partial_python_reader_have_distinct_scopes(self) -> None: + def test_native_runner_and_shared_python_reader_have_explicit_scopes(self) -> None: entry = self.entries["msdmd"] self.assertEqual(entry["status"], "runnable") self.assertEqual(entry["runner"], "msdmd/collect.py") - self.assertEqual(entry["runner_scope"], "msdmd-blocks-only") - self.assertEqual( - entry["native_ingestion"], - { - "status": "partial", - "runner": "msdmd/module_projection.py", - "scope": "python-symbol-signature-docstring-comment-projection", - "schema": "msdmd/module-projection.schema.json", - "manifest": "msdmd/python-module-reader.json", - }, - ) + self.assertEqual(entry["runner_scope"], "native-and-supplemental") + self.assertEqual(entry["native_ingestion"]["runner"], "msdmd/collect.py") + self.assertEqual(entry["native_ingestion"]["manifest"], "msdmd/readers.py") + self.assertIn("project_python_bytes", (ROOT / "msdmd/native_code.py").read_text()) - def test_helper_identity_limitations_are_explicit(self) -> None: + def test_helper_identity_and_extraction_limits_are_explicit(self) -> None: text = (ROOT / "msdmd/SKILL.md").read_text(encoding="utf-8") - for statement in ( - "does not diagnose duplicate IDs", - "edge `from` and `source_id`", - "bare entry IDs", - "### Shipped helper limitations", - "emitted without diagnostics", - "does not repair\nthe collector or visualizer runtime", - ): + for statement in ("schema 2", "qualified addresses", "duplicate IDs", "--require-fact", + "--snapshot-identity", "not a complete secret detector", "full TSDoc validation"): self.assertIn(statement, text) - self.assertNotIn("collection addresses additionally\nqualify", text) + self.assertNotIn("does not diagnose duplicate IDs", text) + self.assertTrue((ROOT / "msdmd/references/implemented-readers.md").is_file()) def test_llm_publication_matches_owning_sources(self) -> None: source = (ROOT / "llms/metadata.py").read_text(encoding="utf-8") entries = build.parse_text(source, source=Path("llms/metadata.py")) definitions = next(entry.fields for entry in entries if entry.id == "key_definitions") self.assertIn("native-first", definitions["msdmd"]) - self.assertIn("collector remains block-only", definitions["msdmd"]) - self.assertIn("partial Python reader", definitions["msdmd"]) + self.assertIn("schema-2 collector integrates", definitions["msdmd"]) + self.assertIn("shared Python comment attachment", definitions["msdmd"]) self.assertNotIn("each source module declares", source) generated = build.generate(build.collect(ROOT), self.index["repo"].split("/")[-1]) self.assertEqual((ROOT / "llms.txt").read_text(encoding="utf-8"), generated) @@ -130,7 +118,7 @@ def test_native_ingestion_preserves_evidence_and_authority_boundaries(self) -> N def test_repository_collection_replays_from_owning_blocks(self) -> None: path = ROOT / "skill-lib_msdmd.ts" generated = render_typescript( - collect(ROOT, self.index["repo"]), import_path="./msdmd/collection", + collect(ROOT, self.index["repo"], snapshot_identity=True), import_path="./msdmd/collection", ) self.assertEqual(path.read_text(encoding="utf-8"), generated) collection = load_collection(path) diff --git a/tests/test_native_collection.py b/tests/test_native_collection.py new file mode 100644 index 0000000..4cb7eba --- /dev/null +++ b/tests/test_native_collection.py @@ -0,0 +1,230 @@ +"""Executable acceptance fixtures for the MSDMD native collection contract. + +Usage: python -m unittest tests.test_native_collection +These tests exercise static extraction only; they never execute fixture code. +""" +from __future__ import annotations + +import json +import subprocess +import tempfile +import unittest +from pathlib import Path + +from msdmd.collect import SCHEMA_VERSION, collect, collection_errors + +ROOT = Path(__file__).resolve().parents[1] + + +class NativeCollectionTest(unittest.TestCase): + def test_native_only_repository_needs_no_msdmd_redeclarations(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "src").mkdir() + (root / "src" / "example.py").write_text( + '''"""Example package.""" +from pathlib import Path + +__all__ = ["double"] + +def double(value: int) -> int: + """Return twice the supplied value.""" + return value * 2 +''', + encoding="utf-8", + ) + (root / "pyproject.toml").write_text( + '''[project] +name = "example" +version = "1.0.0" +released = 2026-09-16 +dependencies = ["httpx>=1"] + +[build-system] +requires = ["hatchling"] +''', + encoding="utf-8", + ) + (root / ".github").mkdir() + (root / ".github" / "CODEOWNERS").write_text("/src/example/ @example/maintainers\n", encoding="utf-8") + (root / "SKILL.md").write_text("---\nname: example\ndescription: Example skill.\n---\n", encoding="utf-8") + (root / "package.json").write_text(json.dumps({"name": "example-ui", "api_token": "do-not-publish", "dependencies": {"react": "^19"}}), encoding="utf-8") + (root / "workflow.yml").write_text("name: checks\non:\n push:\njobs:\n test:\n steps:\n - run: python -m unittest\n", encoding="utf-8") + (root / "api.ts").write_text('/** Return a greeting.\n * @param name recipient\n */\nexport function greet(name: string): string { return `hello ${name}`; }\nimport { readFileSync } from "node:fs";\n', encoding="utf-8") + (root / "run.sh").write_text("#!/bin/sh\n# shellcheck shell=sh\nexit 0\n", encoding="utf-8") + (root / "example.service").write_text("[Service]\nExecStart=/usr/bin/example\nEnvironment=A=1\nEnvironment=B=2\n", encoding="utf-8") + (root / ".gitignore").write_text("build/\n!important.txt\n", encoding="utf-8") + (root / "requirements.txt").write_text( + "httpx>=1\nprivate-lib @ https://user:token@example.invalid/private.whl\n", + encoding="utf-8", + ) + (root / "LICENSE").write_text("Mozilla Public License Version 2.0\n", encoding="utf-8") + (root / "icon.svg").write_text( + '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"><title>ExampleFixture icon.\n', + encoding="utf-8", + ) + (root / "llms.txt").write_text("# Example\n- **Source** = repository\n", encoding="utf-8") + + collection = collect(root, "example", source_commit="a" * 40) + + self.assertEqual(SCHEMA_VERSION, collection["schema_version"]) + self.assertEqual([], collection["declarations"]) + self.assertFalse(collection_errors(collection)) + namespaces = {fact["convention"]["namespace"] for fact in collection["facts"]} + self.assertTrue({"python.pep257", "python.source-metadata", "python.pyproject", "github.codeowners", "markdown.yaml-frontmatter", "npm.package-json", "yaml.document", "typescript.source-metadata", "typescript.documentation-comment", "posix.shebang", "systemd.unit", "git.ignore", "python.requirements-file", "license.text", "svg.document-metadata", "llms.txt"}.issubset(namespaces)) + symbol = next(fact for fact in collection["facts"] if fact["kind"] == "callable-declaration") + self.assertEqual("double", symbol["subject"]["identity"]) + self.assertEqual("syntactically-observed", symbol["standing"]) + self.assertEqual("behavior not inferred", symbol["projection"]["loss"]) + ownership = next(fact for fact in collection["facts"] if fact["kind"] == "review-ownership") + self.assertEqual("review-assignment-only", ownership["native"]["value"]["authority"]) + pyproject = next(fact for fact in collection["facts"] if fact["convention"]["namespace"] == "python.pyproject" and fact["kind"] == "structured-document") + self.assertEqual({"$type": "toml-date", "value": "2026-09-16"}, pyproject["native"]["value"]["project"]["released"]) + serialized = json.dumps(collection, sort_keys=True) + self.assertNotIn("do-not-publish", serialized) + self.assertNotIn("user:token", serialized) + self.assertIn("sensitive_fields_redacted", {item["code"] for item in collection["diagnostics"]}) + self.assertEqual(0, collection["coverage"]["unsupported_files"]) + self.assertEqual("not-evaluated", collection["coverage"]["verified_behavior"]) + + def test_qualified_sources_and_duplicate_identity_diagnostics(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + for name in ("a.py", "b.py"): + (root / name).write_text( + "# === DOCS ===\n# id: shared\n# summary: first\n# === END DOCS ===\n", + encoding="utf-8", + ) + with (root / "a.py").open("a", encoding="utf-8") as handle: + handle.write("# === DOCS ===\n# id: shared\n# summary: conflicting\n# === END DOCS ===\n") + + collection = collect(root, "example", block_names=("DOCS",), source_commit="b" * 40) + + addresses = [item["address"] for item in collection["declarations"]] + self.assertEqual(3, len(addresses)) + self.assertNotEqual(addresses[0], addresses[2]) + self.assertEqual(addresses[0], addresses[1]) + errors = collection_errors(collection) + self.assertEqual(["duplicate_block_id"], [item["code"] for item in errors]) + self.assertEqual("identity-conflict", collection["conflicts"][0]["kind"]) + + def test_same_symbol_name_in_two_packages_stays_distinct(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + for package in ("alpha", "beta"): + directory = root / package + directory.mkdir() + (directory / "math.py").write_text("def parse(value: str) -> str:\n return value\n", encoding="utf-8") + + collection = collect(root, "example", source_commit="9" * 40) + + facts = [item for item in collection["facts"] if item["kind"] == "callable-declaration"] + self.assertEqual(["parse", "parse"], [item["subject"]["identity"] for item in facts]) + self.assertEqual(2, len({item["subject"]["address"] for item in facts})) + + def test_python_strings_do_not_create_block_declarations(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "fixture.py").write_text( + '''EXAMPLE = """# === DOCS === +# id: not_a_declaration +# summary: fixture text +# === END DOCS ===""" +''', + encoding="utf-8", + ) + + collection = collect(root, "example", block_names=("DOCS",), source_commit="c" * 40) + + self.assertEqual([], collection["declarations"]) + + def test_python_declared_encoding_and_source_lines_survive(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "latin.py").write_bytes( + b"# -*- coding: latin-1 -*-\n\ndef caf\xe9(value: int) -> int:\n \"\"\"Doubler.\"\"\"\n return value * 2\n" + ) + + collection = collect(root, "example", source_commit="f" * 40) + + fact = next(item for item in collection["facts"] if item["kind"] == "callable-declaration") + self.assertEqual("caf\N{LATIN SMALL LETTER E WITH ACUTE}", fact["subject"]["identity"]) + self.assertEqual(3, fact["source"]["location"]["start_line"]) + self.assertEqual(5, fact["source"]["location"]["end_line"]) + self.assertIn("span", fact["source"]["location"]) + self.assertFalse(collection_errors(collection)) + + def test_replay_is_byte_identical_for_same_snapshot(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "module.py").write_text("def answer() -> int:\n return 42\n", encoding="utf-8") + first = collect(root, "example", source_commit="d" * 40) + second = collect(root, "example", source_commit="d" * 40) + next_revision = collect(root, "example", source_commit="e" * 40) + + self.assertEqual( + json.dumps(first, sort_keys=True, separators=(",", ":")), + json.dumps(second, sort_keys=True, separators=(",", ":")), + ) + self.assertNotEqual(first["facts"][0]["address"], next_revision["facts"][0]["address"]) + + def test_generated_collection_is_accounted_for_without_self_ingestion(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "module.py").write_text("VALUE = 1\n", encoding="utf-8") + output = root / "example_msdmd.ts" + output.write_text("first generated value\n", encoding="utf-8") + first = collect(root, "example", source_commit="1" * 40) + output.write_text("different generated value\n", encoding="utf-8") + second = collect(root, "example", source_commit="1" * 40) + + self.assertEqual(first["source"]["snapshot_sha256"], second["source"]["snapshot_sha256"]) + self.assertEqual("excluded", next(item["status"] for item in first["discovery"] if item["file"] == "example_msdmd.ts")) + + def test_invalid_native_source_stays_visible(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "broken.json").write_text('{"open": ', encoding="utf-8") + collection = collect(root, "example", source_commit="e" * 40) + + self.assertEqual(["invalid_json"], [item["code"] for item in collection_errors(collection)]) + entry = next(item for item in collection["discovery"] if item["file"] == "broken.json") + self.assertEqual("invalid", entry["status"]) + + def test_declared_revision_must_match_available_git_head(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "module.py").write_text("VALUE = 1\n", encoding="utf-8") + subprocess.run(["git", "init", "-q", str(root)], check=True) + subprocess.run(["git", "-C", str(root), "config", "user.name", "Fixture"], check=True) + subprocess.run(["git", "-C", str(root), "config", "user.email", "fixture@example.invalid"], check=True) + subprocess.run(["git", "-C", str(root), "add", "module.py"], check=True) + subprocess.run(["git", "-C", str(root), "commit", "-qm", "fixture"], check=True) + + collection = collect(root, "example", source_commit="0" * 40) + + self.assertIn("source_revision_mismatch", {item["code"] for item in collection_errors(collection)}) + + def test_current_skill_lib_head_satisfies_collection_contract(self) -> None: + revision = subprocess.run( + ["git", "-C", str(ROOT), "rev-parse", "HEAD"], + check=True, + capture_output=True, + text=True, + ).stdout.strip() + + collection = collect(ROOT, "The-Interdependency/skill-lib", source_commit=revision) + + self.assertEqual(revision, collection["source"]["revision"]) + self.assertFalse(collection_errors(collection)) + self.assertGreater(collection["coverage"]["native_facts"], 100) + self.assertGreater(collection["coverage"]["supplemental_declarations"], 10) + self.assertIn("json.schema", {fact["convention"]["namespace"] for fact in collection["facts"]}) + applied = {run["reader_id"] for run in collection["reader_runs"] if run["status"] == "applied"} + self.assertTrue({"python-ast", "json-stdlib", "markdown-frontmatter", "yaml-core", "typescript-compiler", "shell-static", "systemd-unit", "gitignore-lines", "python-requirements", "license-text", "svg-metadata", "llms-text"}.issubset(applied)) + self.assertEqual(0, collection["coverage"]["unsupported_files"]) + self.assertFalse(any(item["id"] == "project_overview" and item["file"] == "tests/test_llms_build.py" for item in collection["declarations"])) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_native_encoding_boundary.py b/tests/test_native_encoding_boundary.py new file mode 100644 index 0000000..4997ca4 --- /dev/null +++ b/tests/test_native_encoding_boundary.py @@ -0,0 +1,21 @@ +"""Malformed-source regression: python -m unittest tests.test_native_encoding_boundary.""" +from pathlib import Path +import tempfile +import unittest + +from msdmd.collect import collect, collection_errors + + +class NativeEncodingBoundaryTests(unittest.TestCase): + def test_malformed_code_with_ratios_preserves_other_files_and_reports_error(self): + for suffix in ('.ts', '.rs', '.java', '.cpp', '.h'): + with self.subTest(suffix=suffix), tempfile.TemporaryDirectory() as temp: + root = Path(temp) + name = 'broken' + suffix + (root / name).write_bytes(b'// ratios: loc_comments=1:1 imports_exports=0:0 calls_definitions=0:0\n\xff') + (root / 'healthy.json').write_text('{"name":"preserved"}') + result = collect(root, 'fixture', source_commit='a' * 40) + self.assertTrue(collection_errors(result)) + self.assertTrue(any(d['code'] == 'native_reader_error' and d['source']['file'] == name for d in result['diagnostics'])) + self.assertEqual('invalid', next(d['status'] for d in result['discovery'] if d['file'] == name)) + self.assertTrue(any(f['source']['file'] == 'healthy.json' and f['native']['value'].get('name') == 'preserved' for f in result['facts'])) diff --git a/tests/test_native_review_closure.py b/tests/test_native_review_closure.py new file mode 100644 index 0000000..fe34697 --- /dev/null +++ b/tests/test_native_review_closure.py @@ -0,0 +1,175 @@ +"""PR 111 closure regressions. Usage: python -m unittest tests.test_native_review_closure.""" +import hashlib +import json +from pathlib import Path +import subprocess +import tempfile +import unittest +from unittest.mock import patch + +from msdmd.collect import collect, collection_errors +from msdmd.readers import implementation_digest +import msdmd.readers as readers + + +class NativeReviewClosure(unittest.TestCase): + def collection(self, files, **options): + with tempfile.TemporaryDirectory() as temp: + root = Path(temp) + for name, content in files.items(): + target = root / name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(content.encode() if isinstance(content, str) else content) + return collect(root, 'fixture', source_commit='a' * 40, **options) + + def facts(self, result, kind=None): + return [fact for fact in result['facts'] if kind is None or fact['kind'] == kind] + + def test_xml_sensitive_tags_and_namespaced_attributes_are_redacted(self): + sources = [ + 'DO_NOT_PUBLISH_1visible', + 'DO_NOT_PUBLISH_2DO_NOT_PUBLISH_3', + 'visible', + '', + ] + for source in sources: + with self.subTest(source=source): + result = self.collection({'config.xml': source}) + self.assertFalse(collection_errors(result), result['diagnostics']) + self.assertNotIn('DO_NOT_PUBLISH', json.dumps(result)) + self.assertIn('sensitive_fields_redacted', {d['code'] for d in result['diagnostics']}) + self.assertEqual(hashlib.sha256(source.encode()).hexdigest(), self.facts(result)[0]['source']['content_sha256']) + + def test_xml_unrelated_content_is_preserved(self): + result = self.collection({'config.xml': 'demovisible'}) + self.assertFalse(collection_errors(result)) + self.assertIn('visible', json.dumps(result)) + self.assertNotIn('sensitive_fields_redacted', {d['code'] for d in result['diagnostics']}) + + def test_default_export_assignment_links_the_named_symbol(self): + for expression in ('foo', '(foo)'): + result = self.collection({'a.ts': 'function foo() {} function privateFn() {} export default ' + expression + ';'}) + self.assertFalse(collection_errors(result), result['diagnostics']) + exported = self.facts(result, 'exported-declaration') + self.assertEqual(['foo'], [f['native']['value']['name'] for f in exported]) + binding = self.facts(result, 'local-export')[0]['native']['value'] + self.assertEqual('default', binding['exported_name']) + self.assertEqual([exported[0]['native']['value']['identity']], binding['declaration_identities']) + + def test_named_and_anonymous_default_declarations_are_explicit(self): + for source in ('export default function foo() {}', 'export default function() {}', + 'export default class Named {}', 'export default class {}'): + with self.subTest(source=source): + result = self.collection({'a.ts': source}) + self.assertFalse(collection_errors(result), result['diagnostics']) + declarations = self.facts(result, 'exported-declaration') + self.assertEqual(1, len(declarations)) + self.assertIn('default', declarations[0]['native']['value']['export_names']) + if declarations[0]['native']['value'].get('anonymous'): + self.assertIsNone(declarations[0]['native']['id']) + self.assertEqual('default', self.facts(result, 'local-export')[0]['native']['value']['exported_name']) + + def test_default_expression_and_export_equals_are_not_dropped(self): + for source, name in [('export default 42;', 'default'), ('export default () => 42;', 'default'), + ('const foo = {}; export = foo;', 'export=')]: + result = self.collection({'a.ts': source}) + self.assertFalse(collection_errors(result), result['diagnostics']) + self.assertEqual(name, self.facts(result, 'local-export')[0]['native']['value']['exported_name']) + + def test_literal_python_exports_remain_static(self): + result = self.collection({'a.py': "__all__ = ['a']\ndef a(): pass\n"}, required_sources=['a.py']) + self.assertFalse(collection_errors(result), result['diagnostics']) + value = self.facts(result, 'exports')[0]['native']['value'] + self.assertEqual('static', value['resolution']) + self.assertEqual(['a'], value['names']) + + def test_mutated_or_escaped_python_exports_are_partial(self): + mutations = ["__all__.append('b')", "__all__ += ['b']", "__all__[0] = 'b'", "del __all__[0]", + "alias = __all__; alias.append('b')", "if enabled: __all__ = ['b']", "__all__ = ['b']", + "mutate(__all__)"] + for mutation in mutations: + with self.subTest(mutation=mutation): + result = self.collection({'a.py': "__all__ = ['a']\n" + mutation + '\n'}, required_sources=['a.py']) + self.assertTrue(collection_errors(result)) + self.assertIn('dynamic_python_exports', {d['code'] for d in result['diagnostics']}) + self.assertTrue(all(f['native']['value']['resolution'] != 'static' for f in self.facts(result, 'exports'))) + self.assertEqual('partial', next(d['status'] for d in result['discovery'] if d['file'] == 'a.py')) + + def test_conditional_only_python_exports_are_unresolved(self): + result = self.collection({'a.py': "if enabled: __all__ = ['a']\n"}, required_sources=['a.py']) + self.assertTrue(collection_errors(result)) + self.assertIn('dynamic_python_exports', {d['code'] for d in result['diagnostics']}) + + def test_repeated_spdx_headers_have_distinct_addresses(self): + sources = { + 'a.py': '# SPDX-FileCopyrightText: 2020 A\n# SPDX-FileCopyrightText: 2021 B\n\ndef f(): pass\n', + 'a.ts': '/* SPDX-FileCopyrightText: 2020 A\n * SPDX-FileCopyrightText: 2021 B\n */\nexport const f = 1;\n', + } + for name, source in sources.items(): + with self.subTest(name=name): + result = self.collection({name: source}) + self.assertFalse(collection_errors(result), result['diagnostics']) + licenses = self.facts(result, 'license-declaration') + self.assertEqual(2, len(licenses)) + self.assertEqual(2, len({f['address'] for f in licenses})) + self.assertEqual({'2020 A', '2021 B'}, {f['native']['value']['value'] for f in licenses}) + + def test_typescript_comments_use_innermost_symbol_even_in_empty_bodies(self): + source = """// module-only +function outer() { + // outer-note + function inner() { + // inner-note + } + // outer-end +} +class Box { + // class-note + method() { + // method-note + } +} +""" + result = self.collection({'a.ts': source}) + self.assertFalse(collection_errors(result), result['diagnostics']) + comments = {f['native']['value']['text'].strip(): f for f in self.facts(result, 'comment')} + self.assertEqual('module', comments['// module-only']['subject']['scope']) + for text, expected in [('// outer-note', 'outer#0'), ('// inner-note', 'outer.inner#0'), + ('// outer-end', 'outer#0'), ('// class-note', 'Box#0'), ('// method-note', 'Box.method#0')]: + self.assertIn(text, comments) + self.assertEqual('symbol', comments[text]['subject']['scope']) + self.assertEqual(expected, comments[text]['subject']['identity']) + + def test_typescript_literal_comment_lookalikes_are_not_comments(self): + source = r'const x = "// not-a-comment"; const y = `/* not-a-comment */`; const z = /\/\/not-a-comment/;' + result = self.collection({'a.ts': source}) + self.assertFalse(collection_errors(result), result['diagnostics']) + self.assertFalse(self.facts(result, 'comment')) + + def test_reader_identity_changes_when_universal_parser_changes(self): + implementation_digest.cache_clear() + original = implementation_digest() + path = Path(readers.__file__).parent / 'parsers' / 'universal.py' + read_bytes = Path.read_bytes + def changed(source): + data = read_bytes(source) + return data + b'\n# executable reader dependency changed\n' if source == path else data + try: + implementation_digest.cache_clear() + with patch.object(Path, 'read_bytes', changed): + self.assertNotEqual(original, implementation_digest()) + finally: + implementation_digest.cache_clear() + + def test_gitignore_trailing_spaces_follow_git_escaping(self): + slash = chr(92) + source = ' \nfoo \nbar' + slash + ' \npath/ \n!keep \n' + slash + '#literal \n' + slash + '!literal \n' + result = self.collection({'.gitignore': source}) + self.assertFalse(collection_errors(result)) + rules = [f['native']['value'] for f in self.facts(result, 'ignore-rule')] + self.assertEqual(['foo', 'bar' + slash + ' ', 'path/', 'keep', slash + '#literal', slash + '!literal'], + [rule['pattern'] for rule in rules]) + self.assertEqual([1, 2, 3, 4, 5, 6], [rule['order'] for rule in rules]) + self.assertTrue(rules[2]['directory_only']) + self.assertTrue(rules[3]['negated']) + self.assertFalse(rules[5]['negated']) diff --git a/tests/test_native_review_regressions.py b/tests/test_native_review_regressions.py new file mode 100644 index 0000000..e4c2aa5 --- /dev/null +++ b/tests/test_native_review_regressions.py @@ -0,0 +1,132 @@ +"""Reviewed regressions: python -m unittest tests.test_native_review_regressions.""" +import json +from pathlib import Path +import subprocess +import tempfile +import unittest +from unittest.mock import patch + +from msdmd.collect import collect, collection_errors +from msdmd.formats import parse_json, parse_yaml + + +class NativeReviewRegressions(unittest.TestCase): + def collection(self, files, **options): + with tempfile.TemporaryDirectory() as temp: + root = Path(temp) + for name, content in files.items(): + target = root / name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(content if isinstance(content, bytes) else content.encode()) + return collect(root, 'fixture', source_commit='a' * 40, **options) + + def facts(self, result, namespace=None, kind=None): + return [f for f in result['facts'] if (namespace is None or f['convention']['namespace'] == namespace) + and (kind is None or f['kind'] == kind)] + + def test_missing_comment_parser_retains_uncertified_candidates_and_fails_closed(self): + source = '// === DOCS ===\n// id: rescued\n// owner: team\n// === END DOCS ===\nexport const x = 1;\n' + with patch('msdmd.native_code.subprocess.run', side_effect=FileNotFoundError()): + result = self.collection({'a.ts': source}) + self.assertTrue(collection_errors(result)) + candidates = [d for d in result['diagnostics'] if d['code'] == 'supplemental_comment_extraction_unavailable'] + self.assertTrue(candidates) + self.assertIn('rescued', json.dumps(candidates)) + self.assertFalse(result['declarations']) + + def test_ambiguous_header_block_candidates_are_not_silent_success(self): + source = '// === DOCS ===\n// id: header_candidate\n// === END DOCS ===\nint x;\n' + result = self.collection({'a.h': source}) + self.assertTrue(collection_errors(result)) + self.assertIn('header_candidate', json.dumps(result['diagnostics'])) + self.assertFalse(result['declarations']) + + def test_systemd_continuations_preserve_separators_and_skip_comments(self): + source = '[Service]\nExecStart=/bin/echo one' + chr(92) + '\n# skipped\n; skipped too\n two\n' + result = self.collection({'a.service': source}) + self.assertFalse(collection_errors(result)) + directive = self.facts(result, 'systemd.unit', 'unit-directive')[0] + self.assertEqual('/bin/echo one two', directive['native']['value']['value']) + self.assertEqual(2, directive['source']['location']['start_line']) + self.assertEqual(5, directive['source']['location']['end_line']) + + def test_every_systemd_environment_assignment_is_redacted(self): + for value in ('A=1 API_TOKEN=DO_NOT_PUBLISH_a18 PASSWORD=DO_NOT_PUBLISH_b19 SAFE=ok', + '"A=a b" "API_TOKEN=DO_NOT_PUBLISH_c20 extra" SAFE=ok'): + with self.subTest(value=value): + result = self.collection({'a.service': '[Service]\nEnvironment = ' + value + '\n'}) + self.assertFalse(collection_errors(result)) + published = json.dumps(result) + self.assertNotIn('DO_NOT_PUBLISH', published) + self.assertIn('SAFE=ok', published) + self.assertIn('sensitive_fields_redacted', published) + + def test_unimplemented_environment_escaping_is_withheld_and_partial(self): + source = '[Service]\nEnvironment=A=1 API' + chr(92) + 'x5fTOKEN=DO_NOT_PUBLISH_d21\n' + result = self.collection({'a.service': source}, required_sources=['a.service']) + self.assertTrue(collection_errors(result)) + self.assertNotIn('DO_NOT_PUBLISH', json.dumps(result)) + self.assertIn('unsupported_systemd_environment_syntax', {d['code'] for d in result['diagnostics']}) + + def test_requirement_includes_do_not_satisfy_required_source_policy(self): + for directive in ('-r prod.txt', '-c constraints.txt', '--requirement=prod.txt', '--constraint constraints.txt', '-rprod.txt'): + with self.subTest(directive=directive): + result = self.collection({'requirements.txt': directive + '\n'}, required_sources=['requirements.txt']) + self.assertTrue(collection_errors(result)) + self.assertIn('unresolved_requirement_include', {d['code'] for d in result['diagnostics']}) + self.assertEqual('partial', next(d['status'] for d in result['discovery'] if d['file'] == 'requirements.txt')) + self.assertTrue(self.facts(result, kind='requirements-option')) + + def test_json_numeric_lexemes_survive_javascript_projection(self): + value = parse_json(b'{"large":9007199254740993,"fraction":0.12345678901234567890,"negative_zero":-0,"safe":42,"half":1.5}') + self.assertEqual({'$type': 'json-number', 'lexeme': '9007199254740993'}, value['large']) + self.assertEqual('0.12345678901234567890', value['fraction']['lexeme']) + self.assertEqual('-0', value['negative_zero']['lexeme']) + self.assertEqual(42, value['safe']) + self.assertEqual(1.5, value['half']) + wire = subprocess.run(['node', '-e', 'process.stdout.write(JSON.stringify(JSON.parse(require("node:fs").readFileSync(0,"utf8"))))'], + input=json.dumps(value), text=True, capture_output=True, check=True).stdout + self.assertEqual(value, json.loads(wire)) + result = self.collection({'data.json': '{"large":9007199254740993}'}) + self.assertFalse(collection_errors(result)) + self.assertEqual('9007199254740993', self.facts(result, kind='structured-document')[0]['native']['value']['large']['lexeme']) + + def test_explicit_integral_yaml_float_is_already_supported(self): + value = parse_yaml(b'num: !!float 1\n') + self.assertIsInstance(value['num'], float) + self.assertEqual(1.0, value['num']) + + def test_local_typescript_exports_keep_aliases_and_type_only_standing(self): + source = 'function foo() {} function privateFn() {} type T = {x: number}; export {foo as renamed}; export type {T};' + result = self.collection({'a.ts': source}) + self.assertFalse(collection_errors(result), result['diagnostics']) + exports = self.facts(result, kind='local-export') + self.assertEqual({'renamed', 'T'}, {f['native']['value']['exported_name'] for f in exports}) + by_name = {f['native']['value']['exported_name']: f['native']['value'] for f in exports} + self.assertEqual('foo', by_name['renamed']['local_name']) + self.assertFalse(by_name['renamed']['type_only']) + self.assertTrue(by_name['T']['type_only']) + public = {f['native']['value']['name'] for f in self.facts(result, kind='exported-declaration')} + self.assertEqual({'foo', 'T'}, public) + + def test_ant_project_xml_is_not_maven(self): + source = 'not-maven' + result = self.collection({'build.xml': source}) + self.assertFalse(collection_errors(result)) + self.assertFalse(self.facts(result, 'maven.pom')) + self.assertTrue(self.facts(result, 'xml.document', 'structured-document')) + + def test_unnamespaced_pom_requires_model_version_discriminator(self): + source = '4.0.0demo' + result = self.collection({'pom.xml': source}) + self.assertFalse(collection_errors(result)) + self.assertTrue(self.facts(result, 'maven.pom', 'dependency')) + + def test_svg_uses_same_no_dtd_utf8_boundary_as_other_xml(self): + source = ']>&x;' + result = self.collection({'bad.svg': source.encode('utf-16')}) + self.assertTrue(collection_errors(result)) + self.assertFalse(self.facts(result, 'svg.document-metadata')) + good = self.collection({'good.svg': 'Safe'}) + self.assertFalse(collection_errors(good)) + self.assertEqual('Safe', self.facts(good, 'svg.document-metadata')[0]['native']['value']['title']) diff --git a/tests/test_native_standards.py b/tests/test_native_standards.py new file mode 100644 index 0000000..6f48f1b --- /dev/null +++ b/tests/test_native_standards.py @@ -0,0 +1,279 @@ +"""End-to-end native reader fixtures: run python -m unittest tests.test_native_standards. + +All source metadata is supplied as inert fixture bytes. Tests distinguish syntax +extraction, required information, source identity and claimed runtime evidence. +""" +from __future__ import annotations + +import base64 +import json +import os +from pathlib import Path +import subprocess +import sys +import tempfile +import unittest +from unittest.mock import patch + +from msdmd.collect import collect, collection_errors +from msdmd.formats import parse_json, parse_yaml, parse_xml +from msdmd.module_projection import project_python_bytes +from msdmd.readers import read_native + +ROOT = Path(__file__).resolve().parents[1] + + +class NativeStandardsTests(unittest.TestCase): + def collection(self, files: dict[str, str | bytes], **options): + with tempfile.TemporaryDirectory() as temp: + root = Path(temp) + for name, content in files.items(): + path = root / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(content.encode() if isinstance(content, str) else content) + return collect(root, 'fixture', source_commit='a' * 40, **options) + + def facts(self, result, namespace=None, kind=None): + return [f for f in result['facts'] if (namespace is None or f['convention']['namespace'] == namespace) + and (kind is None or f['kind'] == kind)] + + def test_yaml_core_nested_aliases_and_typed_keys_are_preserved(self): + value = parse_yaml(b'on: [push]\nx: &x {yes: true, no: false}\ny: *x\nnum: !!float 1\nresponse: {200: ok, "200": other}\n') + self.assertEqual(['push'], value['on']) + self.assertEqual({'yes': True, 'no': False}, value['x']) + self.assertEqual(value['x'], value['y']) + self.assertIsInstance(value['num'], float) + self.assertEqual('yaml-mapping', value['response']['$type']) + self.assertEqual([200, '200'], [v['key'] for v in value['response']['entries']]) + self.assertEqual({'text': 'false'}, parse_yaml(b'text: !!str false\n')) + + def test_unsafe_or_ambiguous_serializations_are_rejected(self): + cases = [(parse_json, b'{"a":1,"a":2}'), (parse_json, b'{"x":NaN}'), + (parse_json, b'{"x":1e999}'), (parse_yaml, b'x: 1\nx: 2'), + (parse_yaml, b'x: &a [*a]'), (parse_yaml, b'x: !unsafe data'), + (parse_yaml, b'x: {<<: {a: 1}}'), (parse_yaml, b'x: !!bool 1'), + (parse_xml, b']>&e;')] + for parser, source in cases: + with self.subTest(source=source): + with self.assertRaises(Exception): parser(source) + + def test_frontmatter_full_structure_is_available_without_redeclaration(self): + result = self.collection({'SKILL.md': '---\nname: example\ninputs:\n - name: thing\n required: true\n---\n# Usage\n'}) + self.assertFalse(collection_errors(result)) + self.assertEqual([], result['declarations']) + self.assertIn('inputs', self.facts(result, 'markdown.yaml-frontmatter')[0]['native']['value']['fields']) + + def test_python_docstring_dialects_emit_structured_parameters(self): + docs = { + 'sphinx': ':param value: The input.\n:type value: int\n:returns: Twice.\n:rtype: int', + 'google': 'Args:\n value (int): The input.\n\nReturns:\n int: Twice.', + 'numpy': 'Parameters\n----------\nvalue : int\n The input.\n\nReturns\n-------\nint\n Twice.'} + for name, doc in docs.items(): + with self.subTest(dialect=name): + code = 'def double(value: int) -> int:\n """Double.\n\n' + '\n'.join(' ' + line for line in doc.split('\n')) + '\n """\n return value * 2\n' + result = self.collection({'a.py': code}) + fact = self.facts(result, 'python.pep257', 'documentation')[0] + self.assertEqual('double', fact['subject']['identity']) + self.assertTrue(any(v.get('arg_name') == 'value' for v in fact['native']['value']['fields'])) + self.assertFalse(collection_errors(result)) + + def test_python_shared_attachment_and_blank_line_identity(self): + code = '# leading note\ndef run(x: int):\n # interior note\n return x\n' + first = self.collection({'a.py': code}) + second = self.collection({'a.py': '\n\n' + code}) + for kind in ('callable-declaration', 'comment'): + self.assertEqual([v['address'] for v in self.facts(first, kind=kind)], [v['address'] for v in self.facts(second, kind=kind)]) + self.assertNotEqual(first['source']['snapshot_sha256'], second['source']['snapshot_sha256']) + projection = project_python_bytes(code.encode(), source_path='a.py', repo='fixture', revision='a' * 40) + self.assertTrue(any(v['record_type'] == 'metadata' and v['text'] == 'leading note' for v in projection)) + for fact in self.facts(first, kind='comment'): + self.assertEqual('run', fact['subject']['identity']) + + def test_python_never_executes_fixture_or_dynamic_exports(self): + result = self.collection({'a.py': 'raise RuntimeError("must not run")\n__all__ = get_names()\n'}) + self.assertFalse(collection_errors(result)) + self.assertIn('dynamic_python_exports', {d['code'] for d in result['diagnostics']}) + self.assertEqual('partial', next(v['status'] for v in result['discovery'] if v['file'] in {'a.py', 'a.ts', 'api.json'})) + + def test_typescript_multiline_members_jsdoc_tags_and_string_fences(self): + code = '''const fixture = `// === DOCS === +// id: fake +// === END DOCS ===`; +export class Client { + /** Read a value. + * @param name The requested name. + * @returns Its value. + * @custom preserved + */ + read( + name: string + ): number { return 1; } +} +''' + result = self.collection({'a.ts': code}) + self.assertFalse(collection_errors(result), result['diagnostics']) + self.assertFalse(result['declarations']) + docs = self.facts(result, 'typescript.documentation-comment') + self.assertTrue(any('read' in f['subject']['identity'] for f in docs)) + self.assertIn('custom', json.dumps(docs)) + + def test_missing_typescript_runtime_is_unsupported_not_empty_success(self): + with patch('msdmd.native_code.subprocess.run', side_effect=FileNotFoundError()): + result = self.collection({'a.ts': 'export const x = 1;'}, required_sources=['*.ts']) + self.assertTrue(collection_errors(result)) + self.assertIn('reader_dependency_unavailable', {d['code'] for d in result['diagnostics']}) + self.assertEqual('unsupported', next(v['status'] for v in result['discovery'] if v['file'] in {'a.py', 'a.ts', 'api.json'})) + + def test_native_source_language_documentation_and_symbol_attachment(self): + fixtures = {'a.rs': ('/// Double.\npub fn double(x: i32) -> i32 { x*2 }\n', 'rustdoc', 'double'), + 'A.java': ('public class A {\n/** Read.\n * @param x value\n */\n public int read(int x) { return x; }\n}\n', 'javadoc', 'A.read'), + 'a.c': ('/** Double.\n * @param x value\n */\nint twice(int x) { return x*2; }\n', 'doxygen', 'twice'), + 'a.hpp': ('class A { public:\n/** Read. */\nint read(int x) { return x; }\n};', 'doxygen', 'A.read')} + for path, (source, namespace, identity) in fixtures.items(): + with self.subTest(language=path): + result = self.collection({path: source}) + self.assertFalse(collection_errors(result), result['diagnostics']) + docs = self.facts(result, namespace, 'documentation-comment') + self.assertEqual(identity, docs[0]['subject']['identity']) + + def test_ambiguous_headers_and_macro_context_remain_visible(self): + result = self.collection({'a.h': 'int x;', 'a.rs': 'foo!();'}, required_sources=['a.h']) + self.assertTrue(collection_errors(result)) + self.assertTrue({'ambiguous_header_language', 'unresolved_compile_context'}.issubset({d['code'] for d in result['diagnostics']})) + + def test_source_spdx_headers_are_actual_comments(self): + result = self.collection({'a.rs': '// SPDX-License-Identifier: MIT\npub fn f() {}'}) + self.assertEqual('MIT', self.facts(result, 'spdx.source-header')[0]['native']['value']['value']) + + def test_openapi_yaml_operations_and_local_or_external_refs(self): + result = self.collection({'api.yaml': 'openapi: 3.1.0\ninfo: {title: test, version: "1"}\npaths:\n /items:\n get:\n operationId: listItems\n responses:\n "200":\n $ref: other.json#/response\n'}) + self.assertFalse(collection_errors(result)) + operation = self.facts(result, 'openapi.document', 'api-operation')[0] + self.assertEqual('listItems', operation['native']['id']) + self.assertEqual('paths:GET /items', operation['subject']['identity']) + self.assertEqual(False, self.facts(result, 'metadata.reference')[0]['native']['value']['network_access']) + + def test_json_schema_unknown_fields_and_citation(self): + result = self.collection({'s.json': json.dumps({'$schema': 'https://json-schema.org/draft/2020-12/schema', '$id': 'urn:example', 'type': 'object', 'x-custom': [1, True]}), + 'CITATION.cff': 'cff-version: 1.2.0\ntitle: Example\nauthors:\n - family-names: Example\ndoi: 10.123/example\n'}) + self.assertFalse(collection_errors(result)) + self.assertEqual([1, True], self.facts(result, 'json.schema')[0]['native']['value']['x-custom']) + self.assertEqual('10.123/example', self.facts(result, 'citation.cff')[0]['native']['id']) + + def test_unknown_standard_versions_do_not_satisfy_required_policy(self): + result = self.collection({'api.json': '{"openapi":"99.0.0","paths":{}}'}, required_sources=['api.json']) + self.assertTrue(collection_errors(result)) + self.assertEqual('partial', next(v['status'] for v in result['discovery'] if v['file'] in {'a.py', 'a.ts', 'api.json'})) + self.assertTrue(self.facts(result, 'openapi.document', 'api-description')) + self.assertFalse(self.facts(result, 'openapi.document', 'api-operation')) + + def test_sarif_and_junit_are_reported_evidence_not_verified_behavior(self): + result = self.collection({'scan.sarif': json.dumps({'version': '2.1.0', 'runs': [{'tool': {'driver': {'name': 'test'}}, 'results': [{'ruleId': 'X', 'message': {'text': 'problem'}}]}]}), + 'junit.xml': ''}) + self.assertFalse(collection_errors(result)) + self.assertEqual('reported-evidence', self.facts(result, 'sarif', 'analysis-result')[0]['standing']) + self.assertEqual(['reported-pass', 'failure'], [f['native']['value']['result'] for f in self.facts(result, 'junit.xml', 'test-result')]) + self.assertEqual('not-evaluated', result['coverage']['verified_behavior']) + + def test_spdx_and_cyclonedx_artifacts_preserve_native_ids(self): + result = self.collection({'bom.json': json.dumps({'spdxVersion': 'SPDX-2.3', 'SPDXID': 'SPDXRef-DOCUMENT', 'packages': [{'SPDXID': 'SPDXRef-pkg', 'name': 'pkg'}]}), + 'cyclone.json': json.dumps({'bomFormat': 'CycloneDX', 'specVersion': '1.6', 'components': [{'bom-ref': 'pkg', 'name': 'pkg', 'components': [{'bom-ref': 'child', 'name': 'child'}]}]})}) + self.assertFalse(collection_errors(result)) + self.assertEqual('SPDXRef-pkg', self.facts(result, 'spdx.json', 'artifact-package')[0]['native']['id']) + self.assertEqual(2, len(self.facts(result, 'cyclonedx.json', 'artifact-component'))) + + def test_duplicate_native_ids_are_reported_without_dropping_witnesses(self): + result = self.collection({'api.json': json.dumps({'openapi': '3.1.0', 'paths': {'/a': {'get': {'operationId': 'same'}}, '/b': {'get': {'operationId': 'same'}}}})}) + self.assertEqual(2, len(self.facts(result, 'openapi.document', 'api-operation'))) + self.assertIn('duplicate_native_identifier', {d['code'] for d in collection_errors(result)}) + + def test_dsse_statement_is_decoded_without_signature_claim(self): + statement = {'_type': 'https://in-toto.io/Statement/v1', 'subject': [{'name': 'app', 'digest': {'sha256': 'a'*64}}], 'predicateType': 'example', 'predicate': {}} + result = self.collection({'att.json': json.dumps({'payloadType': 'application/vnd.in-toto+json', 'payload': base64.b64encode(json.dumps(statement).encode()).decode(), 'signatures': []})}) + self.assertFalse(collection_errors(result)) + self.assertEqual('app', self.facts(result, 'in-toto.statement', 'attested-subject')[0]['native']['id']) + self.assertIn('unverified_signature', {d['code'] for d in result['diagnostics']}) + + def test_package_manifests_lockfiles_and_reuse_are_integrated(self): + result = self.collection({'Cargo.toml': '[package]\nname="demo"\n[dependencies]\nx="1"\n[target."cfg(unix)".build-dependencies]\ny="2"\n', + 'Cargo.lock': 'version=3\n[[package]]\nname="x"\nversion="1.0"\n', + 'package-lock.json': '{"lockfileVersion":3,"packages":{"node_modules/x":{"version":"1.0"}}}', + 'REUSE.toml': 'version=1\n[[annotations]]\npath="src/**"\nSPDX-License-Identifier="MIT"\n'}) + self.assertFalse(collection_errors(result)) + self.assertEqual(2, len(self.facts(result, 'cargo.manifest', 'dependency'))) + self.assertEqual(1, len(self.facts(result, 'cargo.lockfile', 'locked-package'))) + self.assertEqual(1, len(self.facts(result, 'npm.lockfile', 'locked-package'))) + self.assertEqual(1, len(self.facts(result, 'reuse.toml', 'license-rule'))) + + def test_codeowners_precedence_and_ownerless_exemption(self): + result = self.collection({'CODEOWNERS': '* @ignored\n', '.github/CODEOWNERS': '* @team\n/docs/\n'}) + self.assertFalse(collection_errors(result)) + rules = self.facts(result, 'github.codeowners', 'review-ownership') + self.assertEqual(3, len(rules)) + self.assertTrue(any(f['native']['value']['owners'] == [] for f in rules)) + self.assertIn('shadowed', json.dumps(rules)) + + def test_doxygen_dotnet_and_maven_xml(self): + files = {'doc.xml': 'f', + 'net.xml': 'F.', + 'pom.xml': 'ga1'} + result = self.collection(files) + self.assertFalse(collection_errors(result)) + for namespace, kind in [('doxygen.xml', 'documented-symbol'), ('dotnet.xml-doc', 'documented-symbol'), ('maven.pom', 'dependency')]: + self.assertTrue(self.facts(result, namespace, kind)) + + def test_required_facts_are_witnessed_and_missing_information_fails(self): + policy = [{'file': '*.json', 'convention': 'npm.package-json', 'kind': 'dependency'}] + ok = self.collection({'package.json': '{"dependencies":{"x":"1"}}'}, required_facts=policy) + missing = self.collection({'package.json': '{"name":"empty"}'}, required_facts=policy) + self.assertFalse(collection_errors(ok)) + self.assertTrue(collection_errors(missing)) + self.assertEqual('policy-evaluated', ok['coverage']['information_availability']) + self.assertEqual('provided', ok['requirements'][0]['status']) + + def test_source_discovery_reports_limits_symlinks_and_exclusions(self): + with tempfile.TemporaryDirectory() as temp: + root = Path(temp) + (root / 'large.json').write_text('x'*100) + (root / 'secret.env').write_text('secret') + (root / '.env').write_text('secret') + (root / 'link.json').symlink_to('/etc/passwd') + (root / 'node_modules').mkdir() + result = collect(root, 'fixture', source_commit='a'*40, max_file_bytes=10, required_sources=['large.json']) + ledger = {v['file']: v['status'] for v in result['discovery']} + self.assertEqual('excluded', ledger['.env']) + self.assertNotIn('secret', json.dumps(result['facts'])) + self.assertNotEqual('supported', ledger['link.json']) + self.assertEqual(1, result['coverage']['excluded_subtrees']) + self.assertTrue(collection_errors(result)) + + def test_large_collection_chunks_roundtrip_without_code_execution(self): + from msdmd.collect import render_typescript + from msdmd.visualize import load_collection + result = self.collection({'a.py': "\n".join(f"def f{i}(): return {i}" for i in range(70))}) + text = render_typescript(result, import_path='./collection') + self.assertIn('mergeMsdmdFactChunks', text) + with tempfile.TemporaryDirectory() as temp: + path = Path(temp) / 'collection.ts' + path.write_text(text) + self.assertEqual(result, load_collection(path)) + path.write_text('export default defineMsdmdCollectionV2({facts: mergeMsdmdFactChunks(evil())});') + with self.assertRaises((ValueError, json.JSONDecodeError)): + load_collection(path) + + def test_snapshot_replay_and_cli_drift_do_not_depend_on_git_head(self): + with tempfile.TemporaryDirectory() as temp: + root = Path(temp) + (root / 'a.json').write_text('{"x":1}') + output = root / 'fixture_msdmd.ts' + args = [sys.executable, '-m', 'msdmd.collect', '--root', str(root), '--repo', 'fixture', '--snapshot-identity', '--out', str(output)] + self.assertEqual(0, subprocess.run(args, cwd=ROOT, capture_output=True).returncode) + self.assertEqual(0, subprocess.run(args + ['--check'], cwd=ROOT, capture_output=True).returncode) + (root / '__pycache__').mkdir() + self.assertEqual(0, subprocess.run(args + ['--check'], cwd=ROOT, capture_output=True).returncode) + (root / 'a.json').write_text('{"x":2}') + self.assertEqual(1, subprocess.run(args + ['--check'], cwd=ROOT, capture_output=True).returncode) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_schema_uri_detection.py b/tests/test_schema_uri_detection.py new file mode 100644 index 0000000..c85737f --- /dev/null +++ b/tests/test_schema_uri_detection.py @@ -0,0 +1,61 @@ +"""URI recognition regressions: python -m unittest tests.test_schema_uri_detection.""" +import json +from pathlib import Path +import tempfile +import unittest + +from msdmd.collect import collect, collection_errors +from msdmd.formats import is_json_schema_uri + + +class SchemaUriDetectionTests(unittest.TestCase): + def collection(self, schema, **options): + with tempfile.TemporaryDirectory() as temp: + root = Path(temp) + (root / 'sample.json').write_text(json.dumps({'$schema': schema, 'x-custom': [1, True]})) + return collect(root, 'fixture', source_commit='a' * 40, **options) + + def test_exact_authority_and_canonical_drafts(self): + for uri in ('http://json-schema.org/draft-04/schema#', + 'https://json-schema.org/draft/2020-12/schema', + 'https://JSON-SCHEMA.ORG/draft/2020-12/schema'): + with self.subTest(uri=uri): + self.assertTrue(is_json_schema_uri(uri)) + + def test_host_lookalikes_userinfo_controls_and_nonstrings_rejected(self): + for uri in ('https://json-schema.org.attacker.invalid/schema', + 'https://attacker.invalid/json-schema.org/schema', + 'https://attacker.invalid/?next=https://json-schema.org/schema', + 'https://json-schema.org@attacker.invalid/schema', + 'https://user@json-schema.org/schema', + 'https://json-schema.org:443/schema', + '//json-schema.org/schema', 'ftp://json-schema.org/schema', + ' https://json-schema.org/schema', + 'https://json-schema.org/\nschema', 'https://[invalid/schema', + None, True, 42, ['https://json-schema.org/schema'], + {'uri': 'https://json-schema.org/schema'}): + with self.subTest(uri=uri): + self.assertFalse(is_json_schema_uri(uri)) + + def test_collection_preserves_lookalikes_without_schema_classification(self): + for uri in ('https://attacker.invalid/json-schema.org/schema', + 'https://json-schema.org.attacker.invalid/schema', + ['https://json-schema.org/draft/2020-12/schema']): + with self.subTest(uri=uri): + result = self.collection(uri) + self.assertFalse(collection_errors(result)) + self.assertFalse(any(f['convention']['namespace'] == 'json.schema' for f in result['facts'])) + docs = [f for f in result['facts'] if f['kind'] == 'structured-document'] + self.assertTrue(any(f['native']['value']['$schema'] == uri for f in docs)) + + def test_supported_draft_and_unknown_fields_still_collected(self): + result = self.collection('https://json-schema.org/draft/2020-12/schema') + self.assertFalse(collection_errors(result)) + schemas = [f for f in result['facts'] if f['kind'] == 'schema-description'] + self.assertEqual(1, len(schemas)) + self.assertEqual([1, True], schemas[0]['native']['value']['x-custom']) + + def test_unknown_canonical_draft_is_unresolved_required_scope(self): + result = self.collection('https://json-schema.org/draft/future/schema', required_sources=['sample.json']) + self.assertTrue(collection_errors(result)) + self.assertIn('unsupported_json_schema_draft', {d['code'] for d in result['diagnostics']}) diff --git a/tests/test_visualize.py b/tests/test_visualize.py index b32ef10..500bcde 100644 --- a/tests/test_visualize.py +++ b/tests/test_visualize.py @@ -6,7 +6,7 @@ from pathlib import Path from msdmd.collect import render_typescript -from msdmd.visualize import load_collection, render_mermaid +from msdmd.visualize import _node_id, load_collection, render_mermaid class VisualizeTest(unittest.TestCase): @@ -48,6 +48,27 @@ def test_load_collection_reads_generated_typescript(self) -> None: ) self.assertEqual("sample", load_collection(path)["repo"]) + def test_load_collection_reads_generated_schema_two_with_legacy_name_in_payload(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + path = Path(tmp) / "sample_msdmd.ts" + collection = { + "schema_version": "2.0.0", + "repo": "sample", + "declarations": [], + "facts": [{"note": "defineMsdmdCollection({not the wrapper})"}], + "gaps": [], + "edges": [], + } + path.write_text( + render_typescript(collection, import_path="./msdmd/collection"), + encoding="utf-8", + ) + + loaded = load_collection(path) + + self.assertEqual("2.0.0", loaded["schema_version"]) + self.assertEqual(collection["facts"], loaded["facts"]) + def test_load_collection_reads_hand_authored_typescript(self) -> None: hand_authored = ( "// ratios: loc_comments=10:2 imports_exports=1:0 calls_definitions=1:0\n" @@ -108,11 +129,31 @@ def test_render_mermaid_contains_repo_edges_and_gaps(self) -> None: rendered = render_mermaid(self.sample_collection()) self.assertIn("flowchart TD", rendered) - self.assertIn('repo["sample"]', rendered) - self.assertIn('module_edges["module_edges\\nDEPENDENCIES\\nmodule.py"]', rendered) - self.assertIn('module_edges -- "requires" --> other_module', rendered) + self.assertIn(f'{_node_id("repository:sample")}["sample"]', rendered) + self.assertIn('["module_edges\\nDEPENDENCIES\\nmodule.py"]', rendered) + self.assertIn('-- "requires" -->', rendered) self.assertIn('gap_1[["gap.py\\nmissing: DOCS"]]', rendered) + def test_render_mermaid_keeps_same_entry_id_in_two_files_distinct(self) -> None: + collection = { + "schema_version": "2.0.0", + "repo": "sample", + "declarations": [ + {"address": "msdmd://sample@abc/a.py#block/DOCS/shared", "file": "a.py", "block": "DOCS", "id": "shared", "fields": {}}, + {"address": "msdmd://sample@abc/b.py#block/DOCS/shared", "file": "b.py", "block": "DOCS", "id": "shared", "fields": {}}, + ], + "facts": [], + "gaps": [], + "edges": [], + "diagnostics": [], + } + + rendered = render_mermaid(collection) + + self.assertIn(_node_id(collection["declarations"][0]["address"]), rendered) + self.assertIn(_node_id(collection["declarations"][1]["address"]), rendered) + self.assertNotEqual(_node_id(collection["declarations"][0]["address"]), _node_id(collection["declarations"][1]["address"])) + if __name__ == "__main__": unittest.main()