@c4a/context-cli 0.7.4 → 0.7.8

package/providers/context/skills/configure-indexer-providers/references/guides/code-indexer-skill-authoring.md

@@ -0,0 +1,180 @@
+# Code Indexer Skill authoring
+
+This guide defines the release checklist for a Code Indexer Provider Skill.
+It does not reproduce Context's internal Agent Graph lifecycle. The Provider
+receives validated requirements, scopes, worksets and evidence views and
+returns only its declared structured Results/fragments.
+
+## Minimal package
+
+Use one `context-indexer.yaml` with protocol
+`context.indexer.provider/v1`. Give the Skill a SemVer version and publish the
+complete Bundle with a reproducible integrity digest. Instructions, templates,
+fixtures and portable program entries live below the Skill root. Do not invent
+source-specific manifest names or a second schema tree.
+
+Programs use a structured `runtime: node`, portable `entry` and literal `args`.
+They never use a free-form command. A detector only reports activation signals;
+an inspector only returns bounded evidence/enrichment. Neither is a hard-gate
+authority. CLI profile contracts and verified data-only overlays own mechanical
+rules, metric operators and thresholds.
+
+## Author contract checklist
+
+For generated API tables, test the final Candidate as well as the parser payload
+and template preview. Cover direct and supporting references, partial contracts,
+shared types with different implementation defaults, ambiguous or cross-file
+links, and an approved-page regeneration after the source changes. Keep a known
+field when only part of its implementation can be extracted. Do not equate an
+accepted result with a corrected page.
+
+Document what each supported language adapter actually establishes. Preserve
+written expressions without evaluating arbitrary code, distinguish declaration
+defaults from implementation defaults, and explain unresolved imports or types.
+Unknown material, an unsupported parse, and a renderer contradicting a known fact
+need different responses. Use existing material requests and repair routes;
+neither a new content-quality gate nor a Provider-specific retry ledger is needed.
+
+1. **Responsibility.** Classify supported code modules and produce evidence-
+   bound partitions, logical units, Artifact Bundles and Results. Do not own
+   source authorization, requirement approval, final review, CLI metrics or
+   package publication. Source-specific Note/Sessions layers may contribute
+   declared guidance to a code page; they do not become another primary or
+   turn a conversation's proposed change into implemented code behavior.
+2. **Manifest.** Use the sole `context-indexer.yaml` field tree. Bind domains,
+   profiles, operations/fragments, resources, source roles, logical units,
+   customization support and composition without duplicate aliases.
+3. **Resource composition.** Combine only declared programs, profile-bound
+   instructions, templates and optional detector/inspector resources. Omitted
+   capabilities remain unsupported; natural language cannot add them.
+   Put any Agent-executed grouping rules in those declared instructions or
+   templates so Context delivers them with the current View. A partition
+   strategy id or digest is not an instruction resource. Context selects and
+   records strategy attempts; the Agent returns semantic groups and dispositions,
+   without discovering strategy implementations or managing fallback order.
+4. **Activation and profiles.** Declare strong/supporting/negative signals.
+   Dependency names are candidates, not runtime proof. One module may combine
+   one primary profile with supporting/extensions and selected composers.
+5. **Sources and Artifacts.** Write for a reader outside the indexed module:
+   make responsibility, stable interfaces/entrypoints, handoffs and the core
+   state, failure, operation and source-of-truth facts needed for correct use
+   and attribution discoverable. Declare source roles and logical-unit intent;
+   select only CLI-registered Artifact kinds/policy variants. Keep logical unit
+   identity separate from physical Artifact count, and measure useful coverage
+   by answered profile questions rather than symbol or path counts.
+6. **Inventory protocols.** Close every input member with an explicit
+   disposition. Use stable aggregation, full-path example identity and
+   structured chain decisions; do not substitute page prose for inventory.
+7. **Metrics.** Reference registered metric ids as reader-quality guidance.
+   The CLI may report advisory observations, but a Provider cannot return a
+   pass, threshold, retry count, or risk-acceptance decision.
+8. **Revision boundary.** Hard contract or source failures block at their
+   owner. Reader-quality feedback reopens the same Author or Composer through
+   `context revise`; it does not create a metric retry ledger or risk Gate.
+9. **Reader questions.** Declare reusable question templates with stable refs,
+   target domains and allowed evidence contracts. Do not make a question id
+   globally unique to one SubjectKey group.
+10. **Inspector safety.** Accept only the versioned stdin request and bounded
+    authorized evidence view; emit strict JSON within limits. Never read the
+    repository, environment or network implicitly, and never expose raw
+    config values, secrets or unbounded stderr/stdout.
+11. **Base gates.** Do not reduce source scope integrity, identity, evidence,
+    requirement, disposition, reference-only or provenance gates. Provider
+    integrity identifies content; it does not grant pass authority.
+12. **Anonymous fixtures.** Cover at least a component library, Web app, API
+    service, SDK/library and runtime/worker with neutral paths and identifiers.
+13. **Release tests.** Validate the manifest/resource ledger, run positive and
+    negative fixtures, forward-test the complete Skill, pack it, reinstall the
+    exact artifact and compare Bundle bytes/digest.
+14. **Content ownership.** Public technology belongs in the community Skill;
+    company-wide infrastructure belongs in a separate namespaced Provider;
+    repository, service, team and business mappings belong in business/project
+    Providers. Community fixtures remain anonymous.
+15. **Marketplace layout.** Archives keep one top-level Skill directory with
+    `SKILL.md`, the manifest and referenced runtime resources. Exclude tests,
+    caches, credentials, local paths and Host-specific temporary manifests.
+16. **Material gaps.** Return a canonical question disposition in the same
+    main Result when required evidence is missing. Never render a gap as an
+    empty page or speculative prose. Registered Markdown or tool material may
+    enrich the same main indexing batch before Candidate generation; do not
+    create a separate answer operation, Candidate, checkpoint or Review. The
+    CLI projects allowed enrichment material into that same Authorized
+    Workset View; Providers must not reopen registered sources themselves.
+17. **Backend profiles.** Test neutral RPC/HTTP, Gateway, Event/function,
+    Cron/worker, sync/reconciliation, stateful service/storage and library
+    shapes. Local facts remain baseline when optional remote metadata is absent.
+18. **Versioning.** Use Skill/Provider SemVer, exact Provider pins and Bundle
+    integrity. Fixed dependencies require exact versions and resolved
+    integrity. `@context-indexer-origin` is required on workspace-local customization
+    files and grants no authority. It is not required on Provider bundle files.
+19. **Trust boundary.** Skill/manifest describes capabilities; the verified
+    Bundle supplies bytes; workspace customization supplies project deltas;
+    CLI contracts supply hard rules. Keep these four authorities distinct.
+20. **Requirement direction.** `IndexRequirementSet` constrains registry,
+    extractor and Result in one direction. Apply requirement/registry changes
+    through staged, digest-bound proposals and transactional apply; do not edit
+    a live registry around the Route.
+21. **Program and remote authority.** Programs must pass static policy and the
+    applicable trusted/sandbox authorization. Optional remote tools use a
+    versioned Host Action, exact source-bound request and readable receipt;
+    they never expand scope or perform writes.
+22. **End-to-end recovery.** Test discovery, exact Provider resolution,
+    content-addressed staging, controlled execution, Artifact/Evidence Result
+    validation and crash recovery. A resumed run reuses only complete accepted
+    records and never infers success from a partial receipt.
+23. **Customization ladder.** Preserve this order: Provider only → config →
+    instructions append → one template override → program extension →
+    restricted replace. Document the proof and exit condition at every step;
+    see [Provider selection and customization](./indexer-provider-and-customization.md).
+24. **Batch neutrality.** Write instructions for one semantic task and accept
+    that Context may transport several independent tasks in one Agent step.
+    Never derive identity, ordering, ownership or evidence scope from a task
+    key or batch position. Partition should decide consumer-facing ownership
+    from public anchors and unresolved material; detailed supporting Facts are
+    consumed in the bounded Author View rather than copied into every
+    Partition decision.
+
+The current Route delivers readable task material with goals and constraints
+first, followed by the authorized sources and facts. For behavioral explanations,
+read the complete source excerpts. Copy the displayed `source_items` into the
+section's `source_items`; use Fact references in `facts`, not as source items.
+Context resolves a text item's authorized source spans internally. Inventory
+identities and a repository reference do not identify section source material.
+These process-local excerpts are not new Facts or reader-page metadata. Do not
+reopen the repository or infer behavior from a locator alone when the supplied
+lines do not establish it. Batch size does not define a knowledge page boundary.
+
+Author task resources may point to one shared batch reading file. Read that path
+once, use shared material only for its listed task keys, and consider each task's
+own goals and source excerpts. Context shares identical material, not conclusions:
+prepare a separate result for each task and submit the `results[]` together through
+the current completion command. A retry includes the remaining tasks' material in
+full; no earlier batch file or additional reading command is required.
+
+## Result and composition rules
+
+Exactly one primary layer returns a complete partition/author Result for an
+operation. Pre-author extensions return only declared fragments and cannot
+change ownership, denominator or Subject identity. Post-author composers bind
+one current `PrimaryResultView` and return only a derived proposal fragment;
+an empty composer run still has a receipt. Composer selection is the
+intersection of registry selection, manifest declaration and current profile
+applicability, not array order.
+
+Use canonical SubjectKey schemas and the Context NodeRef formula. All selected
+Providers must reuse the same Node when the SubjectKey is equal. An
+enricher uses the supplied TargetResolutionView (`resolved`, `absent` or
+`ambiguous`) and never guesses identity from a title or path resemblance.
+
+Every Section uses the exact `document_kind`, `reader_goal` and
+`artifact_kind` tuple from the current profile's unique layout mapping. The
+Provider never returns a collection name; Context resolves the collection from
+that tuple and rejects missing or ambiguous mappings.
+
+## Publication gate
+
+Do not publish until the exact packed artifact passes manifest/schema
+validation, anonymous positive/negative fixtures, no-scope-expansion and
+secret-leak tests, deterministic Bundle reconstruction, exact-version install,
+controlled execution and forward tests. Publishing a new version does not make
+existing workspace pins current; workspace selection must re-resolve it.

package/providers/context/skills/configure-indexer-providers/references/guides/indexer-provider-and-customization.md

@@ -0,0 +1,416 @@
+# Indexer Provider selection and customization
+
+This guide is for workspace users and Agents selecting Code, Markdown, Note or Sessions
+Indexer Providers. Provider authors should also read the dedicated
+[Code Indexer](./code-indexer-skill-authoring.md) or
+[Markdown Indexer](./markdown-indexer-skill-authoring.md) authoring guide.
+
+Context is registry-only by default. The durable selection lives in
+`src/indexers.yaml`; `package.json`, discovered Skill paths, Host cache paths,
+resolved transport paths and runtime staging directories are not selection
+authority. A Provider-only project does not create `src/indexer/`.
+
+## Selection flow
+
+Follow `workflow.current` from `context status --format json` or `context run`.
+When the registry is missing, the Route names `src/indexers.yaml` in
+`configuration`: declare the confirmed requirements with `indexers: []`, then
+re-evaluate. The next Route supplies the Provider selection input and completion
+command. An unconfigured project does not begin Partition or require a fabricated
+primary owner. `run --managed --until blocked-or-complete` stops at the same
+configuration or semantic input boundary; it does not make those decisions.
+
+1. Form the complete requirements using the initial registry contract below.
+   Reuse the user's stated meaning and research the selected material. Ask about
+   consequential missing purpose or scope even in managed mode; delegation
+   covers execution and eligible reviews, not unanswered intent. A Provider,
+   registry entry or Result may strengthen it but cannot remove targets,
+   questions, evidence obligations or required owner cells.
+2. Select applicable Providers from the Host-visible Skills and the CLI-bundled
+   catalog already in the current Action input. No separate catalog command,
+   installed-Skill inventory, discovery report, or discovery-only confirmation
+   is required. Use the supplied exact identity and cli-bundled distribution
+   for shipped Providers, even when their Skills are also visible to the Host.
+   For a relevant external Skill, read only its exact Host-exposed frontmatter
+   and sibling `context-indexer.yaml` needed for selection. Do not guess versions
+   or scan `.claude`, `.codex`, `.agents` or arbitrary user directories. Different
+   versions remain distinct; discovery order is not selection precedence.
+3. Submit the semantic `indexers` and any relevant non-CLI `host_visible_skills`
+   through the current Route's `context action complete-current` command. The
+   latter may be empty; it is not an inventory or an additional discovery step.
+4. The CLI performs routing, validation, resolution and staging internally.
+   Shipped Providers load directly from this CLI release; only external
+   Providers may require the returned Host resolution Action. Follow the
+   current Route if a distribution is missing, a version conflicts, or program
+   execution needs authorization. Do not call the low-level commands below as
+   a second production workflow.
+5. The CLI atomically applies the validated registry and any declared
+   customization. A successful static report alone is not write or execution
+   authority. Resume from the returned current Route.
+
+Every required requirement/domain/source/module cell has exactly one primary
+owner. Read scope may overlap for supporting profiles, extensions and
+enrichers. Array order is never precedence. Each Provider layer retains its own
+exact version, integrity, portable distribution, config and resource
+fingerprints.
+For CLI-bundled instruction Providers, these fields record the original
+selection; they are not a requirement to reinstall old bytes when resuming.
+The current CLI supplies its installed Provider's guidance automatically.
+
+## Resuming after a tool update
+
+Continue with the current Route and its supplied source material. Agents do not
+compare Provider, Fact, signature or inventory fingerprints and do not rewrite
+them in an old request. Context rebuilds the internal result from the submitted
+page content and references.
+
+An added parser field or a more complete line range in the same unchanged file
+does not invalidate Author work. Continuation compares selected sources and
+subjects rather than serialized Fact payloads; accepted work retains its
+original request/result pair. New results retain the source references used for
+later updates. Repeated Fact references or reader-question answers are deduplicated;
+multiple sections may answer the same question. A question ID only identifies a
+reader question to cover, not an additional user approval.
+
+Missing references, a changed source file, a different page owner/subject or a
+concurrent write remain meaningful conflicts. Requirements, membership and result
+contracts still determine whether a task can be reused. This does not introduce a
+new Agent protocol, hash-entry step or persistent audit file.
+
+## Provider selection result
+
+Use the current Action's output schema, which defines the accepted Indexer
+entry fields. This is a `complete-current` input, not a replacement registry
+and not the requirements-only bootstrap schema.
+
+For one component-library requirement, the following template selects one
+primary Code Provider. Replace the quoted placeholders using the **current
+Action input**, not values from a different CLI installation:
+
+```yaml
+stage: provider-selection
+host_visible_skills: []
+indexers:
+  - id: component-guide
+    operations: [main-index]
+    requirement_bindings:
+      - requirement_ref: "<requirement.id>"
+        coverage_domains: ["<required-domain>"]
+        owned_scope:
+          ref: "requirement:<requirement.id>#target_scope"
+        role: primary
+    read_scope:
+      refs:
+        - "requirement:<requirement.id>#target_scope"
+        - "requirement:<requirement.id>#evidence_source_scope"
+    profile:
+      primary:
+        id: component-library
+        provider: community
+    providers:
+      - id: community
+        role: primary
+        skill: "<catalog.skill>"
+        version: "<catalog.version>"
+        integrity: "<catalog.integrity>"
+        distribution:
+          kind: cli-bundled
+          locator: "<catalog.distribution.locator>"
+```
+
+- Choose `component-library` only if it matches the reader task and appears in
+  the selected catalog entry's `capabilities.profiles`. For captured documents,
+  notes or conversation summaries, select a profile from the corresponding
+  compatible Provider. Copy the actual catalog identity.
+- Bind each selected requirement and all required coverage domains it owns;
+  the single-domain template is not permission to drop other required domains.
+  `owned_scope` names the target being described. `read_scope` may also include
+  supporting evidence, which does not become another owned target.
+- `profile.primary.provider`, each additional profile's `provider`, and each
+  composer's `provider` reference a layer's `providers[].id`, not a Skill path.
+  Supporting or extension profiles use `profile.additional` with `kind`;
+  composers use `profile.composers`. Select only combinations supported by the
+  manifests; do not add empty customization or speculative config.
+- The current catalog includes domains, target kinds, profile IDs, operations,
+  composers and extension relationships. If more detail is needed, read the
+  selected entry's exact `guidance.skill_path` and `guidance.manifest_path`.
+  These paths and capabilities are reading aids, not fields to copy into the
+  persistent registry. No separate discovery command or cache scan is needed.
+- JSON Schema describes input shapes and accepted values. The CLI additionally
+  checks coverage ownership, scope relationships and Provider composition when
+  submitting. It atomically applies the selection; do not edit `indexers`
+  manually to bypass a rejected result.
+
+## Initial registry: `src/indexers.yaml`
+
+The initial configuration Route provides the registered source boundary view.
+Read it when the source identities are not already available from the current
+source registration results. It is a metadata view, not another source capture
+or a request to scan the repository. Use only the user's agreed source scope.
+
+Read the `context.indexer.registry-bootstrap` schema at the exact path in the
+current Route's required resources. It ships with the CLI, so it does not
+require a workspace SDK reinstall. It describes this **configuration file**,
+not an Action completion payload. It
+covers the requirements-only state before Provider selection: `indexers` must
+be empty here. Later the Provider selection Route fills that array.
+
+Start with this complete YAML example. Replace the example source reference,
+reader goals and coverage domains with the agreed project requirements:
+
+```yaml
+protocol: context.indexer.registry/v1
+requirements:
+  - id: component-guide
+    purpose: Help application developers integrate components and look up their public API.
+    reader_goals: [understand-components, integrate-components]
+    coverage_domains:
+      component-usage: required
+      public-api: required
+    target_scope:
+      targets:
+        - source_ref: repo:20260901/component-library
+    evidence_source_scope:
+      targets:
+        - source_ref: repo:20260901/component-library
+indexers: []
+```
+
+| Field | What to write |
+| --- | --- |
+| `protocol` | Exactly `context.indexer.registry/v1` for the file. |
+| `requirements` | One or more knowledge goals, grouped by reader need; not one entry per file or symbol. |
+| `id` | A unique, readable identifier for this requirement. |
+| `purpose` | Optional short natural-language reader and task purpose; reuse explicit existing goals when absent. |
+| `reader_goals` | One or more readable goal identifiers, such as `integrate-components`. These are not Provider names. |
+| `coverage_domains` | A nonempty map of intended information categories to `required`, `optional` or `out-of-scope`. Provider selection must cover the required categories. |
+| `target_scope.targets` | Sources whose subjects the knowledge should describe. At least one target is required. |
+| `evidence_source_scope.targets` | Sources the Agent may read to support that knowledge. Include the relevant target sources and any agreed supporting documents. At least one is required. |
+| `source_ref` | The source type plus its complete registered name, such as `repo:20260901/component-library`, `file:20260901/usage-guide` or `lark:20260901/faq`. Saved text uses `note:20260908/topic.md` or `sessions:20260908/topic.md`. Preserve the actual name, not these examples. |
+| `module_refs` | Optional on each target; omit for the complete registered source boundary. Supply only known module references for an explicitly narrower scope. Do not invent a module merely because the source is a code module. |
+| `questions` | Optional structured contract-question bindings, not free-text user questions. Omit unless an actual CLI/profile contract supplies their references, versions and digests. Never invent hashes. |
+| `exclusions` | Optional explicit exclusions with `id`, `scope.targets` and a nonempty `reason`. For repository input, optional `paths` lists exact source-relative files or directories, without globs; omitted means the whole named scope. Agreed paths are filtered before Parser and Partition. A shared Indexer retains material still needed by another requirement. Omit when none were agreed. |
+| `indexers` | `[]` until the next Route selects Providers. Do not copy version or integrity values from an unrelated project. |
+
+Requirement, goal, domain and exclusion identifiers use lowercase letters,
+digits and `._/-`; the first character is a letter or digit, and slash-separated
+segments cannot be empty, `.` or `..`. Requirement ids and goal lists must not
+contain duplicates. Each scope lists a source once; put its selected modules in
+that target's `module_refs` rather than repeating the source.
+
+For document-only knowledge, use the selected captured `file:` or `lark:` source,
+or saved `note:` or `sessions:` source, in both scopes. Saved text must first be
+explicitly selected in the project's `sources`; saving alone is not selection. For a code guide supported by a FAQ, keep the code source in the target
+scope and include both code and FAQ in the evidence scope. If the FAQ also needs
+independent knowledge coverage, include it as a target in the appropriate
+requirement; do not silently treat all captured documents as background.
+Source references identify selected source boundaries, not filesystem paths, URLs,
+image ids, span references or content digests. A repo source already registered
+at a package subdirectory remains bounded to that subdirectory when
+`module_refs` is omitted.
+
+Three existing input shapes have different roles:
+
+- `src/indexers.yaml`: `protocol: context.indexer.registry/v1`, `requirements`,
+  and `indexers`.
+- `IndexRequirementSet`: `protocol: context.indexer.requirement-set/v1` and
+  `requirements` only. This is the SDK's requirement value, not the whole file.
+- Diagnostic `inspect-index-requirements --input`: an envelope with
+  `protocol: context.indexer.requirement-inspection-input/v1`, `project_ref`
+  (the workspace root) and `requirements`; optional `question_contracts` are
+  only for real resolved contract questions. It does not accept the whole
+  registry or a bare requirement set, and is not a mandatory bootstrap step.
+
+After editing the named configuration file, run `context status --format json`
+and follow its new current Route. The next step is Provider selection. Do not
+submit the YAML through `complete-current`, fabricate a lifecycle Result,
+restart the workspace or recapture existing sources.
+
+## Six-level customization ladder
+
+Use the first level that closes the CLI-proven capability gap. Do not start at
+a more powerful level because it is convenient.
+
+| Level | Change | Entry evidence | Exit condition |
+| --- | --- | --- | --- |
+| 1. Provider only | Select an existing exact Provider/profile | The confirmed requirements are fully owned by declared capabilities | Final selection validation passes and no project customization files exist |
+| 2. Config | Select declared variants, resources or data-only options | The manifest exposes a closed config schema that covers the difference | Config validates; no instruction, template or program change is needed |
+| 3. Instructions append | Add bounded project guidance | The gap is semantic guidance and does not change contracts, scope, identity, denominators or hard rules | Appended resource closes the gap and the origin/version fingerprint is retained |
+| 4. Template override | Replace one declared template for one profile | The Artifact policy is already valid; only reader organization/rendering differs | One exact template id/profile is overridden; unrelated templates remain Provider-owned |
+| 5. Program extension | Add a fixed local program under the declared indexer root | A structured algorithm is required and smaller levels are proven insufficient | Static policy passes and independent program/dependency authorization is complete |
+| 6. Restricted replace | Replace only the capability named by the final gap proof | Extension cannot satisfy the exact owner cells and a human accepts the larger maintenance boundary | Replacement remains requirement-compatible, content-addressed and explicitly reviewable |
+
+Levels 3–6 are allowed only after the Route returns
+`indexer-customization-required` with a current `capability_gap_proof`. Copy the
+proof into the draft unchanged. A draft cannot weaken requirements, widen
+source scope, copy a parser, add an evaluator, or claim that it has been
+applied. If no safe level closes the gap, stop instead of emitting a
+conforming-looking file.
+
+## Upgrade and conflict handling
+
+For a CLI-bundled instruction Provider, resume with the installed Skill and
+portable distribution. A version or content change alone does not require
+Provider selection, registry edits, source capture or a restart. The CLI
+refreshes the current batch's instruction resources and Route revision;
+the Agent follows the returned Route without comparing fingerprints.
+
+Compatible tasks keep their original request/result records. Instruction or
+template edits do not, by themselves, discard accepted groups or authored
+content. Changes to sources, requirements, executable programs, configuration,
+result contracts or semantic extension inputs remain work invalidation reasons;
+old results must not be relabeled as outputs of a different task.
+
+Executable/external Providers continue using their resolved staged programs.
+Updating instruction delivery does not replace executable code or grant new
+execution permissions. Local customization files remain user-owned:
+
+- An unchanged upstream resource keeps the local override current.
+- A changed instruction resource outside the override refreshes guidance for
+  pending work, without automatically regenerating completed knowledge.
+- A changed resource under an instruction/template/program override returns
+  `indexer-customization-upstream-changed`; rebase or remove the override.
+- Missing, undeclared, escaping or contract-conflicting local resources return
+  `indexer-customization-invalid`.
+- A missing CLI-bundled Provider or selected profile/operation/composer returns
+  the existing Provider selection Action, with its schema and next command.
+  Captured sources and completed knowledge are retained. External distributions
+  that cannot be resolved still require the existing resolution/selection flow.
+- Multiple primary owners return a conflict for explicit resolution. Do not
+  use discovery order or a preferred Provider name as a tie-breaker.
+
+The optional `@context-indexer-origin <skill>@<version>` comment records where
+a local customization began. It grants no trust and never bypasses revalidation.
+
+## Outcome handling
+
+These outcomes all point back to this guide:
+
+| Outcome | Required next action |
+| --- | --- |
+| `indexer-provider-required` | Discover visible entry Skills, route a path-free proposal, and keep the requirement set unchanged. |
+| `provider-unavailable` / `indexer-provider-unavailable` | Follow the current selection/resolution Action to restore the missing capability. A historical bundled content pin alone is not a failure. |
+| `indexer-customization-required` | Follow the six-level ladder using only the returned current gap proof. |
+| `indexer-customization-invalid` | Remove undeclared/escaping/conflicting files, then rebuild and restage the proposal. |
+| `indexer-customization-upstream-changed` | Reconcile the upstream change with every affected override and rerun final validation. |
+
+## Debugging commands
+
+These are diagnostic/manual primitives, not a checklist for normal selection.
+Use them only for an explicit diagnostic or a returned recovery. `--help`
+describes command options, not necessarily the payload fields. Use the current
+Route's schema and the initial registry contract above; prefer Route-returned commands:
+
+```bash
+context indexer catalog --format json
+context indexer inspect-index-requirements --help
+context indexer compare-index-requirements --help
+context indexer route-indexer-provider-selection --help
+context indexer validate-indexer-selection-proposal --help
+context indexer resolve-indexer-providers --help
+context indexer stage-indexer-provider-bundle --help
+context indexer validate-indexer-customization --help
+context indexer prepare-indexer-customization-project --help
+context indexer stage-indexer-project-proposal --help
+context indexer apply-indexer-project --help
+context indexer observe-indexer-project --help
+```
+
+Keep full runtime reports under `.tmp/context-runtime/`. Do not persist Bundle
+bytes, resolution receipts, selection discovery, run ledgers or audit reports
+in `src/`, `knowledge/` or `dist/`.
+
+## Completion check
+
+Selection/customization is complete only when all of these are true:
+
+- the confirmed requirement digest is unchanged;
+- every required owner cell has exactly one primary owner;
+- every Provider is exact-versioned, integrity-checked and staged from a
+  portable distribution;
+- profile variants, SubjectKey authority, config and resources pass final
+  validation;
+- each local change is the smallest proven ladder level and has no unrelated
+  copied resources;
+- program and dependency receipts exist when required and do not claim a
+  sandbox the Host does not provide;
+- the transactional apply observation matches every target digest;
+- a final static/final selection validation passes after apply.
+
+For the complete manifest and execution surface, see
+[Indexer Provider protocol](../reference/indexer-provider-protocol.md).
+
+## Purpose, page selection, and delivery
+
+`purpose` is an optional short description of the intended reader and task.
+Existing `reader_goals` remain valid when it is absent. Context passes this
+requirement through Partition, Author, and Review; it does not classify free
+text against a fixed vocabulary.
+
+After representative reading and necessary scope discussion, substantial new work
+can preserve the decisions in `.tmp/work-start-report.md` before Partition.
+The current workflow supplies `procedure.work-start-report` and
+`template.work-start-report`: a readable report with its existing requirement
+reference, use scenarios, scope choices, proposed classifications, first delivery
+and actual execution settings. Lightweight edits keep a short summary. The report
+is scratch context, not a published Artifact, a new approval or a condition for
+advancing the workflow. On its first presentation, invite the user to read and
+correct it and pause for that response, including in managed mode, unless they
+explicitly waived this reading opportunity. Reuse the response and report when
+continuing the same task; do not add a per-batch pause or report-status field.
+
+Partition may select `artifact_intent` and `template_id` from the current
+Provider catalog, along with `reader_task`, `outline`, `priority`, and
+`delivery_boundary`. These choices are saved in the existing page plan and
+reused by Author retries. Program templates declare `kind: page-program` in the
+Provider's template resources. Only the selected program is included in the
+Author View; procedure templates remain shared instructions. Workspace template
+overrides retain priority over the bundled default.
+
+Selected Code page programs append a deterministic public-contract table to the
+same Candidate as its semantic explanation. Declarations provide field types,
+requiredness, explicit defaults, signatures, and supported registration facts.
+Missing declarations remain explicit; reference tables do not substitute for
+source-backed examples, behavior, or change guidance.
+
+The first readable delivery normally contains one to three pages. Subsequent
+batches contain 30–50 pages, or a smaller final tail. Context retains accepted
+Results across Review, close, and build, then continues the remaining pages.
+`context run --deliver --format json` requests an earlier checkpoint. It keeps
+the current approval rules. Status reports page counts and built preview paths;
+Author task counts are reported separately.
+
+
+## Source-specific Providers and Host switches
+
+The default distribution includes Code, Markdown, Note and Sessions Providers.
+`context-note-indexer` interprets saved records/excerpts/observations;
+`context-sessions-indexer` interprets bounded conversation summaries, with or
+without code associations. Their shared markdown domain reuses document reading
+and profiles; it does not force all sources through Markdown's semantic policy.
+See [note preparation](note.md) and [sessions preparation](sessions.md).
+
+The host owns installation and enabled/disabled switches. Business skills may be
+installed by any supported host channel. Discover relevant currently visible
+`context-…-indexer…` skills and read the real sibling manifest; the prefix alone
+is not compatibility proof. Declare the selected business Provider through the
+existing host_visible_skills and indexers result. It can replace a default without
+enabling that default. CLI validates/resolves what was declared; it does not scan
+host caches or maintain a second business-skill enable registry. Respect explicit
+user exclusions even when the bundled catalog contains the default.
+
+Choose the page owner from reader need. A note may improve an existing guide,
+answer a FAQ or justify a new reference topic. A session without code may justify
+a decision or process guide. Neither saving nor source type requires a new page.
+For a Code/Markdown page retain its primary and include the actual supporting
+source in evidence/read scope. When specialized source interpretation is needed,
+select a Note/Sessions extension layer and the matching namespaced profile
+(`note/component-library` or `sessions/component-library`, for example) with
+`kind: extension`. The manifest declares each supported base. Supporting profiles
+with `kind: supporting` must come from the same primary layer. One primary writes
+the final page; extension guidance does not create another production target.
+
+Optional sessions `changes` records known commit/MR associations in the source
+file. Existing structure.yaml source/section links connect knowledge to it.
+Do not add per-page commit, session or Provider frontmatter. A reference is not
+proof of merging/testing and does not expand source-read authorization.