@c4a/context-cli 0.6.19 → 0.7.0

package/indexers/bundles/context-code-indexer/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: context-code-indexer
+description: Context-managed Provider for evidence-bound code knowledge. Use only when the Context Indexer lifecycle selects this Provider, not as a standalone workflow.
+metadata:
+  context-role: "indexer-provider"
+  context-public-entry: "false"
+  context-provider-version: "1.0.0"
+---
+
+# Context Code Indexer
+
+Provider authors must satisfy
+`node_modules/@c4a/context/docs/guides/code-indexer-skill-authoring.md` and the
+shared Provider/customization guide before publishing or extending this Skill.
+Those documents are authoring contracts; the current workset and Route remain
+execution authority.
+
+Use this Provider only through the Context Indexer lifecycle. The workspace registry selects an exact profile, version, integrity, scope, and operation. Do not scan outside the supplied workset or write project files directly.
+
+The machine-readable authority is `context-indexer.yaml`. Detailed authoring guidance is materialized by Context from the registered Bundle after its file ledger and integrity have been verified.

package/indexers/bundles/context-code-indexer/context-indexer.yaml

@@ -0,0 +1,230 @@
+protocol: context.indexer.provider/v1
+id: context-code-indexer
+version: 1.0.0
+domains: [code]
+
+activation:
+  target_kinds: [repository, package, library, service, application]
+  required_signals:
+    - id: supported-source
+      description: The registered target scope contains source or contract files supported by Context.
+  supporting_signals:
+    - id: stable-entry
+      description: The target exposes a stable entry, protocol, command, route, export, or runtime boundary.
+    - id: usage-material
+      description: The readable scope contains examples, tests, documentation, or operational material.
+  negative_signals:
+    - id: generated-only
+      description: The scope contains only generated artifacts with no authoritative source boundary.
+  agent_questions:
+    - Which stable reader capability groups the complete eligible inventory?
+
+provides:
+  profiles:
+    - monorepo-container
+    - web-application
+    - component-library
+    - sdk-library
+    - cli-tool
+    - plugin-extension
+    - api-service
+    - gateway-facade
+    - domain-service
+    - background-runtime
+    - event-consumer
+    - data-sync-reconciliation
+    - storage-repository
+    - adapter-integration
+    - contract-source
+    - derived-generated-source
+  partition_strategies:
+    - id: public-target-family
+      profiles: [component-library, sdk-library, plugin-extension, contract-source]
+      priority: 100
+    - id: canonical-semantic-subject
+      profiles:
+        - monorepo-container
+        - web-application
+        - component-library
+        - sdk-library
+        - cli-tool
+        - plugin-extension
+        - api-service
+        - gateway-facade
+        - domain-service
+        - background-runtime
+        - event-consumer
+        - data-sync-reconciliation
+        - storage-repository
+        - adapter-integration
+        - contract-source
+        - derived-generated-source
+      priority: 200
+  operations:
+    - id: main-index
+      consumes: context.indexer.main-workset/v1
+      produces: context.indexer.main-result/v1
+      accepts_layer_fragments: [fact-enrichment, template-variables]
+    - id: material-answer
+      consumes: context.indexer.material-question-workset/v1
+      produces: context.indexer.material-answer-result/v1
+      supported_evidence_kinds: [code, contract, configuration, documentation, runbook, test-result, runtime-observation]
+      accepts_layer_fragments: [fact-enrichment]
+  layer_fragments:
+    - kind: derived-artifact-proposal
+      phase: post-author
+      produces: context.indexer.layer-fragment/v1
+  composers:
+    - id: public-contract
+      supported_profiles: [component-library, sdk-library, cli-tool, plugin-extension, api-service, gateway-facade, domain-service, adapter-integration, contract-source, derived-generated-source]
+      contract:
+        instruction: references/composers/public-contract.md
+        primary_requirements: { fact_kinds: [public-surface], artifact_kinds: [content] }
+        derived_artifact_policy:
+          fragment_protocol: context.indexer.layer-fragment/v1
+          fragment_kind: derived-artifact-proposal
+          artifact_policy_variant: standard
+          artifact_kinds: [contract]
+        empty_result: { result_protocol: context.indexer.layer-fragment-result/v1, behavior: empty-fragment-set }
+    - id: protocol-boundary
+      supported_profiles: [web-application, sdk-library, cli-tool, plugin-extension, api-service, gateway-facade, domain-service, background-runtime, event-consumer, data-sync-reconciliation, storage-repository, adapter-integration, contract-source, derived-generated-source]
+      contract:
+        instruction: references/composers/protocol-boundary.md
+        primary_requirements: { fact_kinds: [protocol-operation], artifact_kinds: [contract] }
+        derived_artifact_policy:
+          fragment_protocol: context.indexer.layer-fragment/v1
+          fragment_kind: derived-artifact-proposal
+          artifact_policy_variant: standard
+          artifact_kinds: [contract]
+        empty_result: { result_protocol: context.indexer.layer-fragment-result/v1, behavior: empty-fragment-set }
+    - id: cross-module-chain
+      supported_profiles: [monorepo-container, web-application, component-library, sdk-library, cli-tool, plugin-extension, api-service, gateway-facade, domain-service, background-runtime, event-consumer, data-sync-reconciliation, storage-repository, adapter-integration]
+      contract:
+        instruction: references/composers/cross-module-chain.md
+        primary_requirements: { fact_kinds: [module-dependency], artifact_kinds: [content] }
+        derived_artifact_policy:
+          fragment_protocol: context.indexer.layer-fragment/v1
+          fragment_kind: derived-artifact-proposal
+          artifact_policy_variant: standard
+          artifact_kinds: [content]
+        empty_result: { result_protocol: context.indexer.layer-fragment-result/v1, behavior: empty-fragment-set }
+    - id: contracts-and-chains
+      supported_profiles: [monorepo-container, web-application, component-library, sdk-library, cli-tool, plugin-extension, api-service, gateway-facade, domain-service, background-runtime, event-consumer, data-sync-reconciliation, storage-repository, adapter-integration, contract-source, derived-generated-source]
+      contract:
+        instruction: references/composers/contracts-and-chains.md
+        primary_requirements: { fact_kinds: [contract-binding, module-dependency], artifact_kinds: [contract] }
+        derived_artifact_policy:
+          fragment_protocol: context.indexer.layer-fragment/v1
+          fragment_kind: derived-artifact-proposal
+          artifact_policy_variant: standard
+          artifact_kinds: [contract]
+        empty_result: { result_protocol: context.indexer.layer-fragment-result/v1, behavior: empty-fragment-set }
+    - id: event-flow
+      supported_profiles: [web-application, plugin-extension, api-service, gateway-facade, domain-service, background-runtime, event-consumer, data-sync-reconciliation, adapter-integration, contract-source]
+      contract:
+        instruction: references/composers/event-flow.md
+        primary_requirements: { fact_kinds: [event-binding], artifact_kinds: [content] }
+        derived_artifact_policy:
+          fragment_protocol: context.indexer.layer-fragment/v1
+          fragment_kind: derived-artifact-proposal
+          artifact_policy_variant: standard
+          artifact_kinds: [content]
+        empty_result: { result_protocol: context.indexer.layer-fragment-result/v1, behavior: empty-fragment-set }
+    - id: persistence-boundary
+      supported_profiles: [api-service, gateway-facade, domain-service, background-runtime, event-consumer, data-sync-reconciliation, storage-repository, adapter-integration]
+      contract:
+        instruction: references/composers/persistence-boundary.md
+        primary_requirements: { fact_kinds: [persistence-binding], artifact_kinds: [content] }
+        derived_artifact_policy:
+          fragment_protocol: context.indexer.layer-fragment/v1
+          fragment_kind: derived-artifact-proposal
+          artifact_policy_variant: standard
+          artifact_kinds: [content]
+        empty_result: { result_protocol: context.indexer.layer-fragment-result/v1, behavior: empty-fragment-set }
+    - id: examples-and-documentation
+      supported_profiles: [monorepo-container, web-application, component-library, sdk-library, cli-tool, plugin-extension, api-service, gateway-facade, domain-service, background-runtime, event-consumer, data-sync-reconciliation, storage-repository, adapter-integration, contract-source, derived-generated-source]
+      contract:
+        instruction: references/composers/examples-and-documentation.md
+        primary_requirements: { fact_kinds: [example-candidate], artifact_kinds: [content] }
+        derived_artifact_policy:
+          fragment_protocol: context.indexer.layer-fragment/v1
+          fragment_kind: derived-artifact-proposal
+          artifact_policy_variant: standard
+          artifact_kinds: [examples]
+        empty_result: { result_protocol: context.indexer.layer-fragment-result/v1, behavior: empty-fragment-set }
+    - id: development-and-delivery
+      supported_profiles: [monorepo-container, web-application, component-library, sdk-library, cli-tool, plugin-extension, api-service, gateway-facade, domain-service, background-runtime, event-consumer, data-sync-reconciliation, storage-repository, adapter-integration, contract-source, derived-generated-source]
+      contract:
+        instruction: references/composers/development-and-delivery.md
+        primary_requirements: { fact_kinds: [development-entry], artifact_kinds: [content] }
+        derived_artifact_policy:
+          fragment_protocol: context.indexer.layer-fragment/v1
+          fragment_kind: derived-artifact-proposal
+          artifact_policy_variant: standard
+          artifact_kinds: [content]
+        empty_result: { result_protocol: context.indexer.layer-fragment-result/v1, behavior: empty-fragment-set }
+  source_roles: [authoritative-source, public-contract-source, example-source, operational-source]
+  logical_units:
+    - id: semantic-subject
+      identity: canonical-subject-key
+      artifacts:
+        recommended: [content, contract, examples]
+        supported_policy_variants: [compact, standard, expanded]
+
+provider:
+  instructions:
+    - path: references/indexer.md
+      profiles:
+        - monorepo-container
+        - web-application
+        - component-library
+        - sdk-library
+        - cli-tool
+        - plugin-extension
+        - api-service
+        - gateway-facade
+        - domain-service
+        - background-runtime
+        - event-consumer
+        - data-sync-reconciliation
+        - storage-repository
+        - adapter-integration
+        - contract-source
+        - derived-generated-source
+  templates:
+    - { id: monorepo-container, profile: monorepo-container, path: templates/monorepo-container.md }
+    - { id: web-application, profile: web-application, path: templates/web-application.md }
+    - { id: component-library, profile: component-library, path: templates/component-library.md }
+    - { id: sdk-library, profile: sdk-library, path: templates/sdk-library.md }
+    - { id: cli-tool, profile: cli-tool, path: templates/cli-tool.md }
+    - { id: plugin-extension, profile: plugin-extension, path: templates/plugin-extension.md }
+    - { id: api-service, profile: api-service, path: templates/api-service.md }
+    - { id: gateway-facade, profile: gateway-facade, path: templates/gateway-facade.md }
+    - { id: domain-service, profile: domain-service, path: templates/domain-service.md }
+    - { id: background-runtime, profile: background-runtime, path: templates/background-runtime.md }
+    - { id: event-consumer, profile: event-consumer, path: templates/event-consumer.md }
+    - { id: data-sync-reconciliation, profile: data-sync-reconciliation, path: templates/data-sync-reconciliation.md }
+    - { id: storage-repository, profile: storage-repository, path: templates/storage-repository.md }
+    - { id: adapter-integration, profile: adapter-integration, path: templates/adapter-integration.md }
+    - { id: contract-source, profile: contract-source, path: templates/contract-source.md }
+    - { id: derived-generated-source, profile: derived-generated-source, path: templates/derived-generated-source.md }
+  forbidden_fallbacks: [one-page-per-symbol, ordinal-batch-pages, inferred-runtime-chain]
+  completion_checks: [inventory-disposition-closure, subject-owner-closure, evidence-binding]
+
+customization:
+  supports: [config, instructions-append, template-override, program-extend]
+
+quality_guidance:
+  metric_ids:
+    - inventory-disposition-coverage
+    - duplicated-fact-target-ratio
+    - narrative-enumeration-ratio
+    - normalized-template-repetition-ratio
+    - implementation-body-ratio
+    - reference-only-reader-targets
+    - unresolved-ordinal-partitions
+    - discretionary-artifacts-per-logical-unit
+    - example-candidate-decision-coverage
+    - example-representative-coverage
+    - example-public-target-linkage
+  repair: references/metrics.md

package/indexers/bundles/context-code-indexer/references/composers/contracts-and-chains.md

@@ -0,0 +1,23 @@
+---
+id: context.code-indexer.composer.contracts-and-chains
+kind: procedure
+media-type: text/markdown
+---
+
+# Contracts and chains composer
+
+Use only when `contracts-and-chains` is present in the effective composer set.
+Consume the exact primary view and return post-author proposals, never another
+complete Indexer Result.
+
+Require both `contract-binding` and `module-dependency` facts plus a primary
+`contract` Artifact. A derived `contract` Artifact may summarize how a stable
+contract identity is produced, transported, implemented, consumed, and traced
+across registered modules. Preserve the authoritative schema and distinguish
+generated bindings from source contracts.
+
+Use the existing target, the `standard` policy, and evidence already bound to
+the view. Do not merge unrelated protocols merely because they share a
+transport. If either fact, the primary Artifact, or an evidenced end-to-end
+binding is absent, return `context.indexer.layer-fragment-result/v1` with an
+empty `fragments` array.

package/indexers/bundles/context-code-indexer/references/composers/cross-module-chain.md

@@ -0,0 +1,22 @@
+---
+id: context.code-indexer.composer.cross-module-chain
+kind: procedure
+media-type: text/markdown
+---
+
+# Cross-module chain composer
+
+Run only for the selected composer and the supplied `PrimaryResultView`.
+Derived output supplements an existing target Node; it cannot create scope,
+change ownership, or replace the primary Result.
+
+Require an evidenced `module-dependency` fact and primary `content` Artifact.
+Propose derived `content` only when a stable reader question crosses at least
+two registered module boundaries and every hop has an unambiguous identity and
+evidence. Describe trigger, ordered boundaries, transformations, outcome,
+failure propagation, and recovery without copying each module page.
+
+Use the `standard` policy and view evidence only. Import adjacency, directory
+proximity, or a guessed runtime call is insufficient. Missing requirements,
+an incomplete chain, or an already answered question yields the structured
+empty result: the accepted layer-fragment result with `fragments: []`.

package/indexers/bundles/context-code-indexer/references/composers/development-and-delivery.md

@@ -0,0 +1,22 @@
+---
+id: context.code-indexer.composer.development-and-delivery
+kind: procedure
+media-type: text/markdown
+---
+
+# Development and delivery composer
+
+Run only for an effective `development-and-delivery` workset. It supplements
+the primary target and cannot own repository scope, release authority, or the
+final Indexer Result.
+
+Require an evidenced `development-entry` fact and primary `content` Artifact.
+Propose derived `content` only for module-owned setup, build, test, packaging,
+deployment, release, rollback, or recovery behavior that answers a stable
+reader question. Distinguish local commands from CI orchestration and record
+configuration inputs without copying secret-like values.
+
+Use the existing Node, `standard` policy, and view evidence. Workspace-wide
+processes belong on a container target, not every module. If the required input
+is absent or the view contains no module-owned development/delivery contract,
+return `fragments: []` in the ordinary structured result.

package/indexers/bundles/context-code-indexer/references/composers/event-flow.md

@@ -0,0 +1,21 @@
+---
+id: context.code-indexer.composer.event-flow
+kind: procedure
+media-type: text/markdown
+---
+
+# Event flow composer
+
+Run only from an effective `event-flow` workset. The supplied primary view is
+the complete authority boundary for this invocation.
+
+Require an evidenced `event-binding` fact and primary `content` Artifact.
+Propose derived `content` only when a stable event identity connects producer,
+transport or dispatch, consumer, state effect, retry/idempotency behavior, and
+failure handling. Timers and scheduled triggers qualify only when their
+registration and downstream behavior are explicit.
+
+Keep the current target Node, use `standard`, and cite view evidence. Do not
+invent a producer from a consumer name or infer delivery guarantees from a
+library default. Missing requirements, an unpaired boundary, or no additional
+reader value must return the normal result envelope with `fragments: []`.

package/indexers/bundles/context-code-indexer/references/composers/examples-and-documentation.md

@@ -0,0 +1,22 @@
+---
+id: context.code-indexer.composer.examples-and-documentation
+kind: procedure
+media-type: text/markdown
+---
+
+# Examples and documentation composer
+
+Run only when selected for the current profile. The workset-scoped primary
+view is the sole input; documentation files outside that view are not implicit
+authority.
+
+Require an evidenced `example-candidate` fact and primary `content` Artifact.
+Propose an `examples` Artifact only for maintained usage that demonstrates a
+supported public target, meaningful setup, expected outcome, and important
+constraints. Merge scenario variants and exclude fixtures, generated samples,
+and demos that do not represent supported use.
+
+Use the existing target Node and `standard` policy. Evidence must come from the
+view. When no representative example closes the reader question, or either
+required input is missing, return the structured empty fragment-set result;
+never invent tutorial steps.

package/indexers/bundles/context-code-indexer/references/composers/persistence-boundary.md

@@ -0,0 +1,21 @@
+---
+id: context.code-indexer.composer.persistence-boundary
+kind: procedure
+media-type: text/markdown
+---
+
+# Persistence boundary composer
+
+Run only for an effective `persistence-boundary` selection. Consume the exact
+`PrimaryResultView` and keep all proposals subordinate to its Node and Result.
+
+Require an evidenced `persistence-binding` fact and primary `content`
+Artifact. Derived `content` may connect the domain operation to repository or
+store, model/schema authority, transaction or consistency boundary, caching,
+migration, failure, and recovery. Separate authoritative schema sources from
+generated models and runtime observations.
+
+Use `standard` and existing evidence. Do not infer storage semantics from a
+driver dependency or method name. If the binding, required Artifact, or a
+source-backed persistence question is absent, return a valid empty fragment
+set rather than reading outside the workset.

package/indexers/bundles/context-code-indexer/references/composers/protocol-boundary.md

@@ -0,0 +1,22 @@
+---
+id: context.code-indexer.composer.protocol-boundary
+kind: procedure
+media-type: text/markdown
+---
+
+# Protocol boundary composer
+
+Run only for an effective `protocol-boundary` composer workset and consume its
+exact `PrimaryResultView`. Never discover new scope or claim final Result
+authority.
+
+Require an evidenced `protocol-operation` fact and a primary `contract`
+Artifact. A derived `contract` proposal may connect a stable operation identity
+to transport, request/response or message shapes, provider and consumer,
+errors, compatibility, and authoritative schema evidence. Keep generated
+clients and bindings pointed at their source contract.
+
+Use the existing target Node and `standard` policy. Do not infer operations
+from names or import adjacency. If the required fact/Artifact is missing, the
+provider/consumer pairing is ambiguous, or the primary contract already
+answers the reader question, return a valid result with `fragments: []`.

package/indexers/bundles/context-code-indexer/references/composers/public-contract.md

@@ -0,0 +1,23 @@
+---
+id: context.code-indexer.composer.public-contract
+kind: procedure
+media-type: text/markdown
+---
+
+# Public contract composer
+
+Run only for an effective `public-contract` composer workset. Consume the
+workset-scoped `PrimaryResultView`; do not inspect a broader repository or
+replace the primary Result.
+
+Require an evidenced `public-surface` fact and its owning primary `content`
+Artifact. Propose a `contract` Artifact only when the view establishes stable
+consumer identities, entrypoints, behavior, constraints, and evidence. Group
+related exports, commands, routes, or extension points by the public concept a
+consumer uses; do not enumerate incidental symbols.
+
+Every proposal must retain the existing target Node, use the `standard`
+Artifact policy variant, and cite evidence already present in the view. Return
+only a post-author `derived-artifact-proposal` fragment. If either required
+input is absent or no independent reader question is supported, return the
+normal layer-fragment result with `fragments: []`.

package/indexers/bundles/context-code-indexer/references/indexer.md

@@ -0,0 +1,49 @@
+# Code Indexer authoring contract
+
+Consume only the current workset, normalized parser facts, verified layer input, and scoped evidence views supplied by Context.
+
+## Classify before selecting templates
+
+Classify each requested module from current manifests, stable entries, public contracts, runtime registration, maintained documentation, and source-backed boundary evidence. Select one primary profile and only the additional profiles supplied by the current workset. A directory name, framework dependency, class suffix, or generated file is not sufficient classification evidence.
+
+Read only the templates materialized for the selected profiles. Combine their questions into one deduplicated plan for the reader-visible capability; a template is guidance, not a source of facts, page counts, output paths, thresholds, or authority. Keep a repository container, public contract, runtime boundary, event flow, persistence boundary, adapter, generated-source provenance, and cross-module handoff separate when they answer different reader questions. Do not copy a template outline when source evidence does not support its sections.
+
+## Partition and identity
+
+For partition work, close every inventory member as owned, excluded, or unsupported and use stable semantic subjects. Each member has exactly one primary owner; extension layers may enrich but cannot claim final authority. Do not create ordinal batches or infer identity from display titles, filenames, headings, or traversal order. If no defensible semantic grouping exists, return the protocol failure that permits the CLI-owned catalog fallback.
+
+Use only the ordered partition strategy materialized by Context for the current workset. The order is project-first and authority-bound; do not skip to a CLI builtin, substitute another strategy id, or recalculate an implementation digest. A strategy may group only the canonical members and profiles supplied with that workset.
+
+Group related identities by a capability, entrypoint, protocol boundary, lifecycle stage, state owner, or handoff. A granular catalog is appropriate only when the selected profile and reader goal require a public API, protocol, command, or registry reference. A cross-module chain requires an explicit trigger, source-backed joins on both sides of every boundary, transformations or state handoffs, and a terminal outcome; imports or similar names do not prove execution order.
+
+Create a reader target only from a CLI-supplied declaration, public export, contract declaration, runtime registration, approved Subject, or Partition Subject identity. Import/re-export aliases, ordinary references, internal helpers, and lightweight evidence may enrich their canonical owner but cannot independently authorize a target. Normalize aliases into the supplied canonical identity. Never promote a name merely because it appears in prose or has many inbound references.
+
+## Author Result and evidence
+
+For author work, produce exactly one Result for the supplied logical unit. Keep deterministic catalogs separate from explanatory prose, bind every declaration and Section to current evidence, and select only an Artifact policy variant listed in the workset. Missing material must become a canonical question disposition; never invent an answer or emit placeholder knowledge.
+
+Treat the CLI inventory as the complete denominator, not a sample. Parser facts may prove files, declarations, entries, contracts, and relationships; they do not by themselves prove business meaning, runtime defaults, failure behavior, or ownership. Every relationship must cite the concrete evidence for its own handoff. Do not repeat one whole-page evidence set across unrelated facts, and do not reduce a multi-source fact to one arbitrary primary file.
+
+Close every CLI-supplied example candidate with exactly one decision: link it to its public target, merge it into a canonical example for the same target and scenario, retain it as a documentation example, exclude it with a reason, or request missing material. A retained representative must decide setup, key calls, parameters, and expected behavior as either extracted facts or evidence-backed not-applicable facets. Merge only by the full example identity supplied by Context; filenames and basenames are not identities. Do not omit an unresolved candidate from the decision set, and do not treat a material request as completed linkage.
+
+Explain stable responsibility, inputs, outputs, state and failure boundaries, the next handoff, and the evidence that supports each claim. Keep implementation bodies, generated payloads, exhaustive internal helper lists, and normalized template repetition out of reader prose. Empty Results are valid only when every target receives a legal disposition.
+
+## Post-author composer result
+
+For a post-author workset, use only the effective composer named by Context and the matching composer instruction materialized beside this contract. Consume the complete workset-scoped `PrimaryResultView`; do not reopen discovery, expand scope, change Subject identity or ownership, or return another complete main Result. A composer may emit only the declared `derived-artifact-proposal` kind and Artifact policy.
+
+If a declared primary fact or Artifact requirement is absent, or the view does not support an independent reader question, return the ordinary `context.indexer.layer-fragment-result/v1` with `fragments: []` and the exact consumed view digest. This is a successful structured empty invocation, not a license to inspect temporary files or infer missing content.
+
+## Mechanical audit and revision
+
+Context independently validates inventory closure, owner closure, parser coverage, Artifact completeness, evidence scope, relationship candidates, semantic density, template repetition, enumeration, and implementation-body limits. These dimensions are independent; one strong dimension cannot offset a hard failure in another. Do not alter wording, Markdown syntax, sentence counts, or partitions solely to influence a counter.
+
+For a failed metric, follow the matching entry in `references/metrics.md`. Each entry explains the denominator-preserving repair, a positive example, and an anti-example. It deliberately contains no numeric threshold: use the current CLI audit for actual, recommended, and hard values.
+
+The reference-only reader-target metric is a zero-count hard gate. Context joins the proposed reader-target projection to its own current identity observations and separately rejects targets with no identity observation at all. Provider prose, display titles, filenames, inbound-reference counts, and self-reported target authority cannot satisfy this gate.
+
+Context recomputes example candidate decision coverage over the complete example inventory. Representative coverage and public-target linkage keep undecided and material-request candidates in their denominator, while only a confirmed exclusion removes a candidate. A scenario variant inherits coverage only when its canonical decision chain terminates at a retained representative; it inherits public-target linkage only when that terminal decision links the exact public target.
+
+When the current audit reports a repairable profile failure, revise the complete affected logical-unit set and return a new Result under the same stable problem lineage. Use the reported uncovered identities, failed metric ids, evidence locators, and legal actions. Request material only when reliable correction requires a source, contract, protocol, or access boundary absent from the registered scope. Three failed revisions produce one complete human report; only the explicit non-delegable profile-risk Gate may accept that runtime profile risk, and no baseline integrity failure is bypassable.
+
+Do not return output paths, collection names, quality thresholds, pass/fail decisions, extra owners, ad hoc question contracts, or facts outside the supplied authority. Context validates structure, evidence, layout, metrics, freshness, reconciliation, and final Review independently.