@c4a/context-cli 0.6.18 → 0.7.0

package/plugins/skills/context-code-indexer/templates/sdk-library.md

@@ -0,0 +1,132 @@
+---
+id: context.code-indexer.template.sdk-library
+kind: procedure
+media-type: text/markdown
+---
+
+# SDK and shared library template
+
+Use for `sdk-library`: reusable code packages, component libraries, client
+SDKs, public framework extensions, or shared runtimes consumed through a
+deliberately supported interface. A package being imported elsewhere is not
+enough; confirm its supported entry and consumer contract.
+
+Use the exact sdk-library or component-library profile and Artifact policy
+variant supplied by the workset.
+
+## Evidence pass
+
+Locate:
+
+- package manifest, exports map, public barrels, binary/native entry, or
+  documented import paths;
+- initialization, providers, factories, configuration, and required runtime;
+- public capability families, components, hooks, types, commands, or clients;
+- supported extension/plugin points and lifecycle;
+- compatibility, platform, peer dependency, and version constraints;
+- maintained examples, tests, API comments, and migration/release notes;
+- external protocol schemas and generated declarations or clients;
+- internal implementation, fixtures, demos, and re-export chains that should
+  not become independent reader pages.
+
+Use public exports plus maintained documentation together. An exported symbol
+can still be incidental; a documented stable import path can remain public even
+when it re-exports another implementation.
+
+## Questions the knowledge must answer
+
+1. Who should use this package and what capabilities does it promise?
+2. What are the supported import/initialization paths?
+3. How are public APIs grouped into concepts a consumer can navigate?
+4. What configuration, lifecycle, compatibility, and failure rules apply?
+5. Which examples demonstrate supported use rather than test-only behavior?
+6. Which declarations are generated, and where is their authority?
+7. How is the package built, versioned, and released when that is in scope?
+
+## Suggested knowledge units
+
+- **Library/module map**: purpose, supported entrypoints, capability families,
+  runtime/peer requirements, extension points, and navigation.
+- **Getting started or lifecycle**: installation assumptions, initialization,
+  configuration, teardown, and minimal supported examples evidenced by source.
+- **Capability-family reference**: a coherent group of APIs/components with
+  usage, contracts, constraints, and related types.
+- **Granular API/component reference**: one symbol or component per page only
+  when the package intentionally exposes a granular public contract and the
+  measured preview remains appropriate.
+- **Compatibility and migration**: supported platforms/versions and evidenced
+  breaking or transitional behavior.
+- **Build/release entry**: only module-owned packaging and release behavior.
+
+## Chapter blueprints
+
+```markdown
+# <Library> module map
+## Purpose and intended consumers
+## Supported entrypoints and initialization
+## Capability families
+## Runtime, peer, and platform requirements
+## Configuration and lifecycle
+## Extension points and external protocols
+## Compatibility, build, and release
+## Examples, evidence, and exclusions
+```
+
+For a capability family:
+
+```markdown
+# <Capability family>
+## When to use it
+## Supported imports or components
+## Initialization and configuration
+## API/component contracts
+## Lifecycle, errors, and constraints
+## Minimal source-backed examples
+## Related capabilities and authoritative references
+```
+
+For a granular reference page:
+
+```markdown
+# <Public API or component>
+## Purpose
+## Import and signature/props
+## Required context and configuration
+## Behavior, lifecycle, and errors
+## Supported example
+## Compatibility and source evidence
+```
+
+## Granularity and relationships
+
+Prefer capability families over one page per export. A symbol page is justified
+when consumers search for that exact public identity and its contract contains
+meaningful behavior beyond a signature. Do not copy complete function bodies,
+private members, generated declarations, fixtures, or every re-export.
+
+When a granular public surface would create enumeration-heavy output, keep the
+public identities navigable but aggregate them into capability-family
+Artifacts. Do not split one source into overlapping owners or invent ordinal
+batches to evade the CLI profile contract.
+
+Relate public entries to capability families, configuration, examples, and
+external protocols. Internal call graphs are secondary unless the knowledge
+goal explicitly concerns extension or lifecycle behavior.
+
+## Template composition examples
+
+- A component library may use granular component pages plus family indexes,
+  while its demo site is a separate `web-application` unit.
+- A generated client reads `derived-generated-source.md` and
+  `protocol-boundary.md`; document the supported client surface while naming
+  the upstream schema authority.
+- A library with a plugin host also reads `adapter-integration.md` and
+  `plugin-extension.md`.
+
+## Revise or stop when
+
+- the public boundary cannot be distinguished from internal exports;
+- examples are invented instead of derived from maintained usage or tests;
+- generated declarations have no identifiable authority;
+- every export or component is selected without a consumer-navigation reason;
+- compatibility or lifecycle claims are unavailable but required by the goal.

package/plugins/skills/context-code-indexer/templates/storage-repository.md

@@ -0,0 +1,56 @@
+---
+id: context.code-indexer.template.storage-repository
+kind: procedure
+media-type: text/markdown
+---
+
+# Storage repository template
+
+Use for `storage-repository` when durable state, cache behavior, consistency, or
+recovery is part of the confirmed reader goal. This template supplements the
+service or runtime that owns the operations; it is not a request to catalog
+every model or query.
+
+## Evidence pass
+
+Locate:
+
+- repository/data-access interface and concrete callers;
+- datastore, table, collection, keyspace, entity, or file identity when
+  source-backed;
+- transaction, consistency, cache, lock, idempotency, and concurrency bounds;
+- read/write/query families and domain mapping;
+- schema/migration authority, versioning, and operational recovery;
+- generated models, query helpers, fixtures, and migrations that should remain
+  supporting evidence.
+
+## Questions the knowledge must answer
+
+1. Which service or domain operation owns each read or write family?
+2. What durable or cached state is addressed?
+3. Where are transaction, consistency, locking, and idempotency boundaries?
+4. Which schema or migration source is authoritative?
+5. What failure, migration, or recovery behavior is maintained?
+
+## Chapter blueprint
+
+```markdown
+# <Persistence boundary>
+## Owned state and authoritative schema
+## Repository or data-access entry
+## Callers and operation families
+## Transaction, consistency, cache, and locking behavior
+## Failure, migration, and recovery boundaries
+## Source evidence and excluded query helpers
+```
+
+## Granularity and stop conditions
+
+Group operations by owned state and consistency policy. Split only when schema
+authority, transaction ownership, datastore, or recovery semantics differ.
+Every page must identify real state and caller boundaries with source locators;
+a directory or class inventory is not a persistence model.
+
+Revise or stop when the datastore identity or owning operation is unknown,
+transaction/consistency behavior would be guessed, or generated bindings and
+migrations would dominate reader-facing pages.

package/plugins/skills/context-code-indexer/templates/web-application.md

@@ -0,0 +1,146 @@
+---
+id: context.code-indexer.template.web-application
+kind: procedure
+media-type: text/markdown
+---
+
+# Web and interactive application template
+
+Use only after evidence classifies a module as `web-application`. This covers
+browser applications, server-rendered sites, embedded WebViews, desktop Web
+shells, native mobile/desktop applications, cross-platform UI runtimes, and
+similar interactive modules. The `web-application` identifier is retained for
+the current contract but represents an interactive application boundary, not
+only browser code. It does
+not automatically cover every package containing UI components; a reusable
+component package is usually `sdk-library`.
+
+Use the exact profile and Artifact policy variant supplied by the workset.
+
+## Evidence pass
+
+Locate the concrete application bootstrap and trace outward just far enough to
+find:
+
+- application mounting, server rendering, shell, or host-container entry;
+- route/page/screen registries and navigation guards;
+- page-to-state, loader, query, client, bridge, or controller boundaries;
+- runtime configuration, environment selection, feature registration, and
+  authentication/session initialization;
+- build, local development, test, bundle, and release entrypoints;
+- generated clients, assets, styles, fixtures, and legacy routes that should
+  remain evidence rather than reader-facing pages.
+
+If the route registry is generated, locate both its generator or source of
+truth and the runtime consumer. Do not infer page identity from a directory
+tree when an explicit registry exists.
+
+## Questions the knowledge must answer
+
+A useful application index should let a reader determine:
+
+1. How does the application start, and which runtime or host does it expect?
+2. What are the stable pages/routes/screens and their entry components?
+3. How does a page obtain data or call an external capability?
+4. Which state, session, bridge, or configuration boundaries affect behavior?
+5. How is the module run, debugged, built, and released?
+6. Which implementation details are intentionally outside the knowledge scope?
+
+## Suggested knowledge units
+
+Select only units supported by the confirmed goal and evidence:
+
+- **Application map**: responsibility, runtime, bootstrap, major subsystems,
+  stable dependencies, and navigation to deeper pages.
+- **Route or page registry**: concrete route/page identity, entry component,
+  loader/guard, main data boundary, and source locator. Aggregate related
+  routes when a page-per-route layout would be repetitive.
+- **Data and protocol boundaries**: add application-specific page, state, and
+  session context to the canonical operation record in `protocol-boundary.md`;
+  do not create a second operation registry.
+- **State and host integration**: only stable stores, bridges, extension points,
+  or host contracts that affect multiple pages or public behavior.
+- **Runtime and delivery guide**: module-owned development commands,
+  configuration, build output, deployment/release entry, and evidenced recovery
+  paths.
+- **Cross-layer flow**: a source-backed page-to-client-to-provider chain when
+  both sides are registered sources.
+
+These are possible page families, not a required number of Markdown files.
+
+## Chapter blueprints
+
+An application-map page may use:
+
+```markdown
+# <Application> module map
+## Responsibility and supported runtime
+## Bootstrap sequence
+## Route/page organization
+## State, data, and protocol boundaries
+## Host integrations and extension points
+## Configuration and environment selection
+## Development, build, and release entrypoints
+## Known exclusions and source-of-truth links
+```
+
+A route/page registry may use a compact record rather than prose repetition:
+
+```markdown
+## <Route or page family>
+- Identity and registration:
+- Entry component or controller:
+- Loader, guard, or initialization:
+- Main client/state dependencies:
+- User-visible outcome:
+- Source evidence:
+```
+
+A cross-layer page may use:
+
+```markdown
+# <User interaction> execution path
+## Trigger and route entry
+## UI/state orchestration
+## Protocol request and authoritative contract
+## Provider boundary and response handling
+## Failure, fallback, and observability
+## Source-backed relationship chain
+```
+
+Do not fill a heading with generic text. Omit or mark a section as a material
+gap when the source cannot support it.
+
+## Granularity and relationships
+
+Prefer stable application concepts over one page per component, hook, state
+field, style, generated type, or internal helper. A page registry must contain
+real identities and source locators, not just folder names. A protocol page
+must name concrete operations or contract locations, not merely state that the
+application “uses HTTP”.
+
+Create structured relationships only when registration, call sites, imports
+with unambiguous ownership, or parser evidence support them. Keep inferred
+product intent out of the index.
+
+## Template composition examples
+
+- A server-rendered application with local API routes also reads
+  `api-service.md` and `protocol-boundary.md`.
+- An embedded application with a host bridge also reads `adapter-integration.md` and the
+  applicable `plugin-extension.md` or `protocol-boundary.md` template.
+- A design-system package rendered in a demo application may need separate
+  index units: `sdk-library` for the supported package and `web-application`
+  for the demo host.
+
+## Revise or stop when
+
+- no executable bootstrap or route registry can be located;
+- the proposed output is only a directory summary;
+- protocol semantics depend on unavailable material;
+- generated routes or clients are being mistaken for authoritative behavior;
+- one-symbol-per-page selection expands components or API types without a
+  deliberate public-reference goal.
+
+Resolve these issues before returning the current author Result for mechanical
+audit.

package/plugins/skills/context-code-indexer/tests/fixtures/chapters.json

@@ -0,0 +1,226 @@
+[
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-monorepo-container-chapter",
+    "anonymized": true,
+    "profile": "monorepo-container",
+    "canonical_facts": { "target": { "eligible": true, "bundle_compact_eligible": true } },
+    "artifact_policy_variant": "compact",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:responsibility-and-entry",
+    "title": "Anonymous repository topology",
+    "sections": ["Scope and entry", "Project boundaries", "Build and delivery evidence"],
+    "evidence_condition": "Render only from a complete project inventory and current build evidence.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-web-application-chapter",
+    "anonymized": true,
+    "profile": "web-application",
+    "canonical_facts": { "target": { "eligible": true, "bundle_expanded_eligible": true } },
+    "artifact_policy_variant": "expanded",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:dispatch-and-routing",
+    "title": "Anonymous application routes",
+    "sections": ["Application entry", "Route and page families", "Data and failure boundaries"],
+    "evidence_condition": "Render only from registered entries, routes, and source-backed handoffs.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-component-library-chapter",
+    "anonymized": true,
+    "profile": "component-library",
+    "canonical_facts": { "target": { "eligible": true, "bundle_expanded_eligible": true } },
+    "artifact_policy_variant": "expanded",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:public-capability",
+    "title": "Anonymous component family",
+    "sections": ["Supported imports", "Composition and variants", "Source-backed usage"],
+    "evidence_condition": "Render only for a public component family with current contract evidence.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-sdk-library-chapter",
+    "anonymized": true,
+    "profile": "sdk-library",
+    "canonical_facts": { "target": { "eligible": true, "bundle_expanded_eligible": true } },
+    "artifact_policy_variant": "expanded",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:examples-and-usage",
+    "title": "Anonymous capability family",
+    "sections": ["Consumer purpose", "Initialization and lifecycle", "Maintained examples"],
+    "evidence_condition": "Render only when the public entry and maintained usage are both evidenced.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-cli-tool-chapter",
+    "anonymized": true,
+    "profile": "cli-tool",
+    "canonical_facts": { "target": { "eligible": true } },
+    "artifact_policy_variant": "standard",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:dispatch-and-routing",
+    "title": "Anonymous command family",
+    "sections": ["Command entry", "Arguments and dispatch", "Exit and recovery behavior"],
+    "evidence_condition": "Render only from registered commands and their current handlers.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-plugin-extension-chapter",
+    "anonymized": true,
+    "profile": "plugin-extension",
+    "canonical_facts": { "target": { "eligible": true } },
+    "artifact_policy_variant": "standard",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:compatibility-and-extension",
+    "title": "Anonymous extension boundary",
+    "sections": ["Host contract", "Activation and lifecycle", "Compatibility limits"],
+    "evidence_condition": "Render only when host and extension identities are source-backed.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-api-service-chapter",
+    "anonymized": true,
+    "profile": "api-service",
+    "canonical_facts": { "target": { "eligible": true, "bundle_expanded_eligible": true } },
+    "artifact_policy_variant": "expanded",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:public-capability",
+    "title": "Anonymous service boundary",
+    "sections": ["Protocol registration", "Operation families", "Handler and downstream handoff"],
+    "evidence_condition": "Render only from a complete operation inventory and authoritative registration.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-gateway-facade-chapter",
+    "anonymized": true,
+    "profile": "gateway-facade",
+    "canonical_facts": { "target": { "eligible": true } },
+    "artifact_policy_variant": "standard",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:dependency-handoff",
+    "title": "Anonymous gateway handoff",
+    "sections": ["Inbound boundary", "Mapping and policy", "Downstream catalog"],
+    "evidence_condition": "Render only when both registration and downstream call evidence are current.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-domain-service-chapter",
+    "anonymized": true,
+    "profile": "domain-service",
+    "canonical_facts": { "target": { "eligible": true, "bundle_expanded_eligible": true } },
+    "artifact_policy_variant": "expanded",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:state-and-consistency",
+    "title": "Anonymous stateful capability",
+    "sections": ["Capability entry", "State and transaction boundary", "Failure and consistency"],
+    "evidence_condition": "Render only from observed state operations and adjacent consistency evidence.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-background-runtime-chapter",
+    "anonymized": true,
+    "profile": "background-runtime",
+    "canonical_facts": { "target": { "eligible": true, "bundle_compact_eligible": true } },
+    "artifact_policy_variant": "compact",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:dispatch-and-routing",
+    "title": "Anonymous scheduled runtime",
+    "sections": ["Trigger", "Dispatch branches", "Retry and completion"],
+    "evidence_condition": "Render only from a registered trigger and complete branch disposition.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-event-consumer-chapter",
+    "anonymized": true,
+    "profile": "event-consumer",
+    "canonical_facts": { "target": { "eligible": true } },
+    "artifact_policy_variant": "standard",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:failure-recovery",
+    "title": "Anonymous event consumer",
+    "sections": ["Subscription and dispatch", "Processing outcome", "Retry and delivery"],
+    "evidence_condition": "Render only from source-backed subscription, handler, and failure evidence.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-data-sync-reconciliation-chapter",
+    "anonymized": true,
+    "profile": "data-sync-reconciliation",
+    "canonical_facts": { "target": { "eligible": true, "bundle_expanded_eligible": true } },
+    "artifact_policy_variant": "expanded",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:state-and-consistency",
+    "title": "Anonymous reconciliation flow",
+    "sections": ["Source and trigger", "Transformation and sink", "Checkpoint and repair"],
+    "evidence_condition": "Render only when source, transformation, sink, and recovery boundaries are closed.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-storage-repository-chapter",
+    "anonymized": true,
+    "profile": "storage-repository",
+    "canonical_facts": { "target": { "eligible": true } },
+    "artifact_policy_variant": "standard",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:public-capability",
+    "title": "Anonymous storage boundary",
+    "sections": ["Owned data surface", "Read and write capabilities", "Consistency and failure"],
+    "evidence_condition": "Render only from current schema, query, or client evidence within scope.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-adapter-integration-chapter",
+    "anonymized": true,
+    "profile": "adapter-integration",
+    "canonical_facts": { "target": { "eligible": true, "bundle_compact_eligible": true } },
+    "artifact_policy_variant": "compact",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:dependency-handoff",
+    "title": "Anonymous adapter boundary",
+    "sections": ["Input contract", "Transformation", "Output and failure mapping"],
+    "evidence_condition": "Render only when both sides of the adaptation are explicitly evidenced.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-contract-source-chapter",
+    "anonymized": true,
+    "profile": "contract-source",
+    "canonical_facts": { "target": { "eligible": true } },
+    "artifact_policy_variant": "standard",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:authority-and-generation",
+    "title": "Anonymous protocol authority",
+    "sections": ["Authoritative source", "Services and operations", "Generation and compatibility"],
+    "evidence_condition": "Render only from a fixed contract source and explicit generation boundary.",
+    "empty_behavior": "omit-chapter"
+  },
+  {
+    "protocol": "context.indexer.chapter-fixture/v1",
+    "id": "anonymous-derived-generated-source-chapter",
+    "anonymized": true,
+    "profile": "derived-generated-source",
+    "canonical_facts": { "target": { "eligible": true, "bundle_compact_eligible": true } },
+    "artifact_policy_variant": "compact",
+    "artifact_kind": "content",
+    "reader_question_ref": "question:authority-and-generation",
+    "title": "Anonymous generated surface",
+    "sections": ["Generated boundary", "Upstream authority", "Runtime consumers"],
+    "evidence_condition": "Render only when generator, upstream authority, and consumers are identifiable.",
+    "empty_behavior": "omit-chapter"
+  }
+]

package/plugins/skills/context-code-indexer/tests/fixtures/composers.json

@@ -0,0 +1,82 @@
+[
+  {
+    "protocol": "context.indexer.composer-fixture/v1",
+    "id": "anonymous-public-contract",
+    "anonymized": true,
+    "composer": "public-contract",
+    "profile": "component-library",
+    "primary_input": { "fact_kinds": ["public-surface"], "artifact_kinds": ["content"] },
+    "expected_proposal": { "artifact_policy_variant": "standard", "artifact_kind": "contract" },
+    "empty_result": { "protocol": "context.indexer.layer-fragment-result/v1", "fragments": [] }
+  },
+  {
+    "protocol": "context.indexer.composer-fixture/v1",
+    "id": "anonymous-protocol-boundary",
+    "anonymized": true,
+    "composer": "protocol-boundary",
+    "profile": "web-application",
+    "primary_input": { "fact_kinds": ["protocol-operation"], "artifact_kinds": ["contract"] },
+    "expected_proposal": { "artifact_policy_variant": "standard", "artifact_kind": "contract" },
+    "empty_result": { "protocol": "context.indexer.layer-fragment-result/v1", "fragments": [] }
+  },
+  {
+    "protocol": "context.indexer.composer-fixture/v1",
+    "id": "anonymous-cross-module-chain",
+    "anonymized": true,
+    "composer": "cross-module-chain",
+    "profile": "monorepo-container",
+    "primary_input": { "fact_kinds": ["module-dependency"], "artifact_kinds": ["content"] },
+    "expected_proposal": { "artifact_policy_variant": "standard", "artifact_kind": "content" },
+    "empty_result": { "protocol": "context.indexer.layer-fragment-result/v1", "fragments": [] }
+  },
+  {
+    "protocol": "context.indexer.composer-fixture/v1",
+    "id": "anonymous-contracts-and-chains",
+    "anonymized": true,
+    "composer": "contracts-and-chains",
+    "profile": "monorepo-container",
+    "primary_input": { "fact_kinds": ["contract-binding", "module-dependency"], "artifact_kinds": ["contract"] },
+    "expected_proposal": { "artifact_policy_variant": "standard", "artifact_kind": "contract" },
+    "empty_result": { "protocol": "context.indexer.layer-fragment-result/v1", "fragments": [] }
+  },
+  {
+    "protocol": "context.indexer.composer-fixture/v1",
+    "id": "anonymous-event-flow",
+    "anonymized": true,
+    "composer": "event-flow",
+    "profile": "web-application",
+    "primary_input": { "fact_kinds": ["event-binding"], "artifact_kinds": ["content"] },
+    "expected_proposal": { "artifact_policy_variant": "standard", "artifact_kind": "content" },
+    "empty_result": { "protocol": "context.indexer.layer-fragment-result/v1", "fragments": [] }
+  },
+  {
+    "protocol": "context.indexer.composer-fixture/v1",
+    "id": "anonymous-persistence-boundary",
+    "anonymized": true,
+    "composer": "persistence-boundary",
+    "profile": "api-service",
+    "primary_input": { "fact_kinds": ["persistence-binding"], "artifact_kinds": ["content"] },
+    "expected_proposal": { "artifact_policy_variant": "standard", "artifact_kind": "content" },
+    "empty_result": { "protocol": "context.indexer.layer-fragment-result/v1", "fragments": [] }
+  },
+  {
+    "protocol": "context.indexer.composer-fixture/v1",
+    "id": "anonymous-examples-and-documentation",
+    "anonymized": true,
+    "composer": "examples-and-documentation",
+    "profile": "monorepo-container",
+    "primary_input": { "fact_kinds": ["example-candidate"], "artifact_kinds": ["content"] },
+    "expected_proposal": { "artifact_policy_variant": "standard", "artifact_kind": "examples" },
+    "empty_result": { "protocol": "context.indexer.layer-fragment-result/v1", "fragments": [] }
+  },
+  {
+    "protocol": "context.indexer.composer-fixture/v1",
+    "id": "anonymous-development-and-delivery",
+    "anonymized": true,
+    "composer": "development-and-delivery",
+    "profile": "monorepo-container",
+    "primary_input": { "fact_kinds": ["development-entry"], "artifact_kinds": ["content"] },
+    "expected_proposal": { "artifact_policy_variant": "standard", "artifact_kind": "content" },
+    "empty_result": { "protocol": "context.indexer.layer-fragment-result/v1", "fragments": [] }
+  }
+]