ai-capability-framework 1.0.0-rc.3 → 1.0.0

package/docs/governance/index.md

@@ -1,34 +1,33 @@
 # AICF Governance
 
-AICF governance is a pure contract and analysis layer. It helps maintainers
-review capability lifecycle changes, infer minimum risk, compare versions, and
-understand what else a capability touches before it is exposed to AI systems.
+AICF governance is a pure contract and analysis layer. It helps maintainers review
+capability lifecycle changes, infer minimum risk, compare versions, and understand what
+else a capability touches before it is exposed to AI systems.
 
-Governance APIs do not call models, execute handlers, mutate manifests, write
-stores, or replace your policy engine. They return structured decisions that a
-host app, CI job, or release process can act on.
+Governance APIs do not call models, execute handlers, mutate manifests, write stores, or
+replace your policy engine. They return structured decisions that a host app, CI job, or
+release process can act on.
 
-Runtime controls are separate from governance analysis. Governance can report
-active kill switches or circuit breakers as promotion blockers; the optional
+Runtime controls are separate from governance analysis. Governance can report active
+kill switches or circuit breakers as promotion blockers; the optional
 `ai-capability-framework/controls` subpath evaluates those controls at runtime.
 
-Governed memory is also separate. The optional
-`ai-capability-framework/memory` subpath checks host-owned memory summaries for
-use-case, scope, expiry, consent, and sensitivity before they become model
-context. It does not store or recall memory.
+Governed memory is also separate. The optional `ai-capability-framework/memory` subpath
+checks host-owned memory summaries for use-case, scope, expiry, consent, and sensitivity
+before they become model context. It does not store or recall memory.
 
-Capability-aware security packs are also separate runtime/test artifacts, but
-their assignment metadata lives under `extensions.governance.security_packs`.
-Explicit waivers live under `extensions.governance.security_pack_waivers` and
-must include `pack_id`, `reason`, `reviewer`, and `reviewed_at`. See
+Capability-aware security packs are also separate runtime/test artifacts, but their
+assignment metadata lives under `extensions.governance.security_packs`. Explicit waivers
+live under `extensions.governance.security_pack_waivers` and must include `pack_id`,
+`reason`, `reviewer`, and `reviewed_at`. See
 [security packs](../security/security-packs.md).
 
 ## Governance Gate
 
-`aicf gate` runs the release-oriented checks together: manifest and fixture
-validation, semantic invariants, risk, lifecycle posture, optional compatibility
-baseline checks, impact analysis, eval coverage, security-pack coverage,
-configured provider conformance, and public artifact hygiene.
+`aicf gate` runs the release-oriented checks together: manifest and fixture validation,
+semantic invariants, risk, lifecycle posture, optional compatibility baseline checks,
+impact analysis, eval coverage, security-pack coverage, configured provider conformance,
+and public artifact hygiene.
 
 ```bash
 aicf gate examples --env production --format json
@@ -38,31 +37,31 @@ See [governance gate](gate.md) for config, defaults, and CI exit codes.
 
 ## Control Plane
 
-`ai-capability-framework/control-plane` provides an optional self-hostable API
-and local reference UI for reviewing governance outputs, policy decision
-records, action/approval queues, runtime controls, eval/security/conformance
-status, and redacted replay metadata.
+`ai-capability-framework/control-plane` provides an optional self-hostable API and local
+reference UI for reviewing governance outputs, policy decision records, action/approval
+queues, runtime controls, eval/security/conformance status, and redacted replay
+metadata.
 
-The control plane is not a hosted service and does not provide production auth,
-durable storage, workflow orchestration, model calls, provider SDK execution, or
-side-effect execution. See [control plane](../control-plane.md).
+The control plane is not a hosted service and does not provide production auth, durable
+storage, workflow orchestration, model calls, provider SDK execution, or side-effect
+execution. See [control plane](../control-plane.md).
 
 ## Lifecycle
 
-Governance lifecycle status is separate from the current manifest `status`
-field. When a command needs a starting status and `--from` is not supplied,
-AICF maps current manifest status like this:
+Governance lifecycle status is separate from the current manifest `status` field. When a
+command needs a starting status and `--from` is not supplied, AICF maps current manifest
+status like this:
 
 | Manifest status | Governance status |
-| --- | --- |
-| `draft` | `draft` |
-| `experimental` | `review` |
-| `active` | `production` |
-| `deprecated` | `deprecated` |
-| `disabled` | `disabled` |
+| --------------- | ----------------- |
+| `draft`         | `draft`           |
+| `experimental`  | `review`          |
+| `active`        | `production`      |
+| `deprecated`    | `deprecated`      |
+| `disabled`      | `disabled`        |
 
-Supported governance statuses are `draft`, `review`, `approved`, `canary`,
-`production`, `deprecated`, `disabled`, and `removed`.
+Supported governance statuses are `draft`, `review`, `approved`, `canary`, `production`,
+`deprecated`, `disabled`, and `removed`.
 
 Example:
 
@@ -74,26 +73,26 @@ aicf governance lifecycle examples \
   --reason "Ready for controlled review"
 ```
 
-The result includes `allowed`, blocking reasons, warnings, and required actions.
-No files are changed.
+The result includes `allowed`, blocking reasons, warnings, and required actions. No
+files are changed.
 
 ## Risk Compilation
 
-Risk compilation compares the declared `risk_tier` with an inferred minimum risk
-from side effects, lifecycle metadata, auth scope, entity classifications, and
-policy controls.
+Risk compilation compares the declared `risk_tier` with an inferred minimum risk from
+side effects, lifecycle metadata, auth scope, entity classifications, and policy
+controls.
 
 ```bash
 aicf governance risk examples --capability support.refund.prepare_case
 ```
 
-Missing safety controls are blocking. Catalogue-quality gaps, such as missing
-usage guidance, remain warnings unless `--strict` is used.
+Missing safety controls are blocking. Catalogue-quality gaps, such as missing usage
+guidance, remain warnings unless `--strict` is used.
 
 ## Compatibility
 
-Compatibility compares two versions of a capability manifest and classifies the
-change as `compatible`, `requires_minor`, or `breaking`.
+Compatibility compares two versions of a capability manifest and classifies the change
+as `compatible`, `requires_minor`, or `breaking`.
 
 ```bash
 aicf governance compatibility \
@@ -101,21 +100,21 @@ aicf governance compatibility \
   --after examples/support/capabilities/support.refund.prepare_case.yaml
 ```
 
-Breaking changes include adding required input fields, removing inputs, lowering
-risk, lowering approval requirements, adding side effects, or removing
-idempotency/audit controls.
+Breaking changes include adding required input fields, removing inputs, lowering risk,
+lowering approval requirements, adding side effects, or removing idempotency/audit
+controls.
 
 ## Impact
 
-Impact analysis reports directly affected capabilities, entities, evals,
-provider exports, policy references, and coverage gaps from the loaded registry.
+Impact analysis reports directly affected capabilities, entities, evals, provider
+exports, policy references, and coverage gaps from the loaded registry.
 
 ```bash
 aicf governance impact examples --capability support.refund.prepare_case
 ```
 
-F1 impact analysis is registry-local. Trace, tenant, or production-store impact
-can be supplied by later host integrations, but no database is required.
+F1 impact analysis is registry-local. Trace, tenant, or production-store impact can be
+supplied by later host integrations, but no database is required.
 
 ## TypeScript
 

package/docs/governance/lifecycle.md

@@ -1,8 +1,7 @@
 # Lifecycle
 
-Lifecycle checks decide whether a capability can move between governance
-statuses such as draft, review, approved, canary, production, deprecated,
-disabled, and removed.
+Lifecycle checks decide whether a capability can move between governance statuses such
+as draft, review, approved, canary, production, deprecated, disabled, and removed.
 
 Use:
 
@@ -10,5 +9,5 @@ Use:
 node dist/cli.js governance lifecycle examples --capability support.refund.prepare_case --to production
 ```
 
-Lifecycle decisions are structured recommendations. AICF does not mutate
-manifests or deploy capabilities.
+Lifecycle decisions are structured recommendations. AICF does not mutate manifests or
+deploy capabilities.

package/docs/governance/overview.md

@@ -1,8 +1,7 @@
 # Governance Overview
 
-AICF governance checks lifecycle transitions, inferred risk, compatibility,
-impact, eval coverage, security-pack coverage, provider conformance, and public
-artifact hygiene.
+AICF governance checks lifecycle transitions, inferred risk, compatibility, impact, eval
+coverage, security-pack coverage, provider conformance, and public artifact hygiene.
 
 Start with:
 

package/docs/governance/risk-compiler.md

@@ -1,8 +1,7 @@
 # Risk Compiler
 
-The risk compiler compares declared risk to inferred minimum risk from side
-effects, lifecycle, policy, idempotency, audit, auth scoping, and entity
-metadata.
+The risk compiler compares declared risk to inferred minimum risk from side effects,
+lifecycle, policy, idempotency, audit, auth scoping, and entity metadata.
 
 Use:
 
@@ -10,5 +9,5 @@ Use:
 node dist/cli.js governance risk examples --format text
 ```
 
-Safety and runtime correctness issues are errors. Quality or migration gaps are
-warnings unless they affect safety.
+Safety and runtime correctness issues are errors. Quality or migration gaps are warnings
+unless they affect safety.

package/docs/host-responsibilities.md

@@ -1,7 +1,6 @@
 # Host Responsibilities
 
-AICF defines contracts and deterministic checks. Host applications own runtime
-behavior.
+AICF defines contracts and deterministic checks. Host applications own runtime behavior.
 
 Host applications MUST provide or enforce:
 
@@ -10,14 +9,13 @@ Host applications MUST provide or enforce:
 - policy facts used by `deny_if` and `approval_required_if`;
 - approval collection, approval verification, and approval records;
 - handler registries and capability execution;
-- side effects such as writes, sends, refunds, workflow starts, and permission
-  changes;
+- side effects such as writes, sends, refunds, workflow starts, and permission changes;
 - idempotency storage, replay protection, and conflict handling;
 - durable action state, verification state, and audit logs;
 - trace redaction and provider payload retention policies.
 
-AICF decision results and audit previews are inputs to host control logic. They
-are not proof that a real user is authorized and are not durable audit records.
+AICF decision results and audit previews are inputs to host control logic. They are not
+proof that a real user is authorized and are not durable audit records.
 
-Public examples in this repository are synthetic. Do not replace host security
-controls with example permissions, IDs, or policy facts.
+Public examples in this repository are synthetic. Do not replace host security controls
+with example permissions, IDs, or policy facts.

package/docs/implementation-notes/baseline-gaps.md

@@ -1,26 +1,23 @@
 # F0 Baseline Gaps
 
-This note records the F0 baseline reconciliation result for the public
-repository. It is intentionally limited to public implementation facts.
+This note records the F0 baseline reconciliation result for the public repository. It is
+intentionally limited to public implementation facts.
 
 ## Findings
 
-- Core repairs are present: schemas, manifest loading, registry construction,
-  capability decisions, adapter exports, tool-result envelopes, and eval scoring
-  are covered by deterministic tests.
-- Runtime APIs are present under the runtime subpath and provide context,
-  routing, policy, handler execution, action lifecycle, in-memory stores, audit,
-  redaction, and envelope helpers.
-- Provider APIs are present under optional subpaths for OpenAI, Anthropic,
-  Gemini, AI SDK, LangChain, MCP, Semantic Kernel, AWS, observability, live eval,
-  Promptfoo, Langfuse, and MCP server integrations.
-- Release hygiene exists through package contents checks, public artifact
-  checks, workspace hygiene checks, source archive checks, and clean install
-  smoke tests.
-- The explicit `npm run typecheck` command has been added for F0 command
-  compatibility.
-- The current public architecture is documented in
-  `docs/architecture/current-state.md`.
+- Core repairs are present: schemas, manifest loading, registry construction, capability
+  decisions, adapter exports, tool-result envelopes, and eval scoring are covered by
+  deterministic tests.
+- Runtime APIs are present under the runtime subpath and provide context, routing,
+  policy, handler execution, action lifecycle, in-memory stores, audit, redaction, and
+  envelope helpers.
+- Provider APIs are present under optional subpaths for OpenAI, Anthropic, Gemini, AI
+  SDK, LangChain, MCP, Semantic Kernel, AWS, observability, live eval, Promptfoo,
+  Langfuse, and MCP server integrations.
+- Release hygiene exists through package contents checks, public artifact checks,
+  workspace hygiene checks, source archive checks, and clean install smoke tests.
+- The explicit `npm run typecheck` command has been added for F0 command compatibility.
+- The current public architecture is documented in `docs/architecture/current-state.md`.
 
 ## Result
 

package/docs/index.md

@@ -1,20 +1,29 @@
 # AICF Documentation
 
-AI Capability Framework is a governed capability layer for AI-accessible
-application functionality. AICF is not an agent framework.
+AI Capability Framework (AICF) is a provider-agnostic governed capability layer for
+AI-accessible application functionality. AICF is not an agent framework.
 
 Models propose; applications validate, authorize, execute, and audit.
 
 ## Start
 
 1. [Installation](getting-started/installation.md)
-2. [Quickstart](getting-started/quickstart.md)
-3. [Concepts](getting-started/concepts.md)
-4. [OpenAI walkthrough](openai-walkthrough.md)
-5. [Glossary](glossary.md)
+2. [Provider-neutral quickstart](getting-started/provider-neutral-quickstart.md)
+3. [Quickstart](getting-started/quickstart.md)
+4. [Concepts](getting-started/concepts.md)
+5. [OpenAI quickstart](getting-started/openai-quickstart.md)
+6. [Anthropic quickstart](getting-started/anthropic-quickstart.md)
+7. [Gemini quickstart](getting-started/gemini-quickstart.md)
+8. [OpenAI walkthrough](openai-walkthrough.md)
+9. [Glossary](glossary.md)
 
 ## Build The Capability Layer
 
+- Core contracts define public manifests, schemas, validation, and deterministic
+  no-execution decisions.
+- Runtime, providers, governance, evals, security, observability, the control plane, and
+  agent skills are optional surfaces around those contracts.
+
 - [Capability manifests](core/capability-manifests.md)
 - [Entity manifests](core/entity-manifests.md)
 - [Runtime overview](runtime/runtime-overview.md)
@@ -25,6 +34,7 @@ Models propose; applications validate, authorize, execute, and audit.
 ## Connect Providers
 
 - [Provider overview](providers.md)
+- [Choose a runtime](providers/choose-a-runtime.md)
 - [OpenAI](providers/openai.md)
 - [Anthropic Claude](providers/anthropic.md)
 - [Google Gemini](providers/gemini.md)
@@ -54,7 +64,12 @@ Models propose; applications validate, authorize, execute, and audit.
 - [Control plane](control-plane/overview.md)
 - [Release process](public-framework/release-process.md)
 - [Final v1 certification](public-framework/v1-certification.md)
+- [Final certification matrix](public-framework/final-certification-matrix.md)
+- [npm release preflight](public/npm-release-preflight.md)
+- [License decision](public-framework/license-decision.md)
+- [Dependency license exceptions](public/license-exceptions.md)
 - [Compatibility policy](public-framework/compatibility-policy.md)
 - [Deprecation policy](public-framework/deprecation-policy.md)
 - [Security disclosure](public-framework/security-disclosure.md)
 - [API reference](api.md)
+- [Public API policy](api/public-api-policy.md)

package/docs/interoperability.md

@@ -1,7 +1,7 @@
 # Interoperability
 
-AICF describes AI-facing application capabilities. Other frameworks may execute
-or orchestrate those capabilities.
+AICF describes AI-facing application capabilities. Other frameworks may execute or
+orchestrate those capabilities.
 
 Use AICF as the portable contract layer for:
 
@@ -22,11 +22,11 @@ Use host or adjacent runtime frameworks for:
 - durable audit pipelines;
 - production observability.
 
-When integrating with another runtime, keep the boundary explicit: AICF can
-validate and decide whether a capability request is allowed, approval-required,
-or denied, but the runtime must still enforce real auth, produce facts, execute
-or refuse handlers, and persist records.
+When integrating with another runtime, keep the boundary explicit: AICF can validate and
+decide whether a capability request is allowed, approval-required, or denied, but the
+runtime must still enforce real auth, produce facts, execute or refuse handlers, and
+persist records.
 
-See [the adapter guide](adapters.md) for implemented provider/runtime adapters
-and [the adapter status page](adapter-roadmap.md) for reference links and
-priority rationale.
+See [the adapter guide](adapters.md) for implemented provider/runtime adapters and
+[the adapter status page](adapter-roadmap.md) for reference links and priority
+rationale.

package/docs/langchain-runtime.md

@@ -1,13 +1,13 @@
 # LangChain And LangGraph Bridge
 
-The LangChain bridge is an optional provider adapter for applications that
-already use LangChain.js or LangGraph.js. It translates a routed AICF capability
-slice into LangChain tools, executes tool calls through `AicfToolExecutor`, and
-returns serialized model-safe AICF runtime envelopes.
+The LangChain bridge is an optional provider adapter for applications that already use
+LangChain.js or LangGraph.js. It translates a routed AICF capability slice into
+LangChain tools, executes tool calls through `AicfToolExecutor`, and returns serialized
+model-safe AICF runtime envelopes.
 
-It does not install model provider integrations, choose a chat model, expose
-commit tools, persist state, log raw provider payloads, or make root/runtime
-imports depend on LangChain.
+It does not install model provider integrations, choose a chat model, expose commit
+tools, persist state, log raw provider payloads, or make root/runtime imports depend on
+LangChain.
 
 ## Import
 
@@ -27,47 +27,43 @@ import {
 ```
 
 `createDefaultLangChainToolFactory()` dynamically imports the optional
-`@langchain/core/tools` package. Host applications may instead pass a
-compatible `tool` factory.
+`@langchain/core/tools` package. Host applications may instead pass a compatible `tool`
+factory.
 
 ## Tool Bridge
 
-`buildLangChainTools()` builds a normal LangChain tool array from an
-already-routed AICF capability slice. Each generated tool uses a provider-safe
-name, model-safe description, schema, and function that delegates to
-`executeProviderToolCall()`.
+`buildLangChainTools()` builds a normal LangChain tool array from an already-routed AICF
+capability slice. Each generated tool uses a provider-safe name, model-safe description,
+schema, and function that delegates to `executeProviderToolCall()`.
 
-LangChain schema validation is advisory. AICF still performs canonical input
-validation, policy checks, lifecycle checks, approval handling, and model-safe
-envelope formatting.
+LangChain schema validation is advisory. AICF still performs canonical input validation,
+policy checks, lifecycle checks, approval handling, and model-safe envelope formatting.
 
 Minimal usage is: validate manifests, build a routed runtime slice, register
-read/prepare handlers, create or pass a LangChain tool factory, then give the
-generated tools to the host-owned agent or graph.
+read/prepare handlers, create or pass a LangChain tool factory, then give the generated
+tools to the host-owned agent or graph.
 
 ## LangGraph ToolNode
 
 `buildLangGraphToolNode()` is a thin wrapper around a host-supplied `ToolNode`
-constructor. AICF does not import `@langchain/langgraph` by default. The helper
-creates the same AICF-backed tools and passes them to the supplied constructor.
+constructor. AICF does not import `@langchain/langgraph` by default. The helper creates
+the same AICF-backed tools and passes them to the supplied constructor.
 
 ## Boundary
 
-- AICF capability manifests, policy, lifecycle, and runtime envelopes remain the
-  source of truth.
-- Commit, destructive, money-moving, and external-send capabilities are not
-  exported by default and are not executable through LangChain tool calls.
+- AICF capability manifests, policy, lifecycle, and runtime envelopes remain the source
+  of truth.
+- Commit, destructive, money-moving, and external-send capabilities are not exported by
+  default and are not executable through LangChain tool calls.
 - Provider packages such as `@langchain/openai`, `@langchain/anthropic`, and
-  `@langchain/google-genai` are host application dependencies, not AICF
-  dependencies.
-- Raw prompts, provider request/response payloads, traces, credentials, and
-  private diagnostics are not captured by default.
+  `@langchain/google-genai` are host application dependencies, not AICF dependencies.
+- Raw prompts, provider request/response payloads, traces, credentials, and private
+  diagnostics are not captured by default.
 - Live tests are opt-in with `RUN_LIVE_LANGCHAIN=1` and may use fake
   LangChain-compatible tools instead of a real provider model.
 
-Known limitations: no provider-specific LangChain integrations, no model
-selection, no production storage, no automatic approval UI, and no model-exposed
-commit path.
+Known limitations: no provider-specific LangChain integrations, no model selection, no
+production storage, no automatic approval UI, and no model-exposed commit path.
 
 ## Checks
 

package/docs/live-evals.md

@@ -1,61 +1,98 @@
 # Live Evals
 
-Live evals are optional runtime checks that execute synthetic eval cases through
-the OpenAI Responses runtime with a caller-provided client. Import them from:
+Live evals are optional runtime checks that execute synthetic eval cases through a
+caller-provided provider runner. They are provider-neutral by default and keep OpenAI as
+one convenience adapter. Import them from:
 
 ```ts
 import {
+  createOpenAILiveEvalRunner,
   evaluateGate,
   runLiveEvalSuite
 } from "ai-capability-framework/evals-live";
 ```
 
-Default tests use mock clients. No live model call runs in normal CI.
-The public runtime support/billing example is separate from live evals and runs
-without model credentials.
+Default tests use mock clients. No live model call runs in normal CI. The public runtime
+support/billing example is separate from live evals and runs without model credentials.
 
 ## Deterministic Fixtures Vs Live Evals
 
-The Core eval runner scores public candidate-result fixtures without API keys.
-Live evals run the same kind of behavior through the runtime path first, then
-summarize the result into candidate fields such as selected capabilities, tool
-calls, policy status, action state, committed capabilities, and final text.
+The Core eval runner scores public candidate-result fixtures without API keys. Live
+evals run the same kind of behavior through the runtime path first, then summarize the
+result into candidate fields such as selected capabilities, tool calls, policy status,
+action state, committed capabilities, and final text.
 
-The live runner reuses deterministic scorer semantics where possible. It does
-not add LLM-as-judge scoring in this phase.
+The live runner reuses deterministic scorer semantics where possible. It does not add
+LLM-as-judge scoring in this phase.
 
 ## Running A Suite
 
 ```ts
+const runner = createOpenAILiveEvalRunner({
+  client: openAIClient,
+  model: "gpt-4.1-mini"
+});
+
 const results = await runLiveEvalSuite({
   cases,
   contextBuilderFactory: () => contextBuilder,
   executor,
-  model: "gpt-4.1-mini",
-  openAIClient,
   registry,
-  router
+  router,
+  runner
 });
 
 const gate = evaluateGate(results);
 ```
 
-The default gate fails when any eval errors, a safety/policy scorer fails, or
-the average score is below `0.90`.
+The default gate fails when any eval errors, a safety/policy scorer fails, or the
+average score is below `0.90`.
+
+For source-compatible OpenAI callers, `runLiveEvalSuite({ openAIClient, model, ... })`
+still works. New code should pass an explicit runner. Convenience runner factories are
+available for OpenAI Responses, Anthropic Messages, Gemini GenerateContent, and Vercel
+AI SDK `generateText`.
+
+Non-OpenAI example:
+
+```ts
+import { createAnthropicLiveEvalRunner } from "ai-capability-framework/evals-live";
+
+const runner = createAnthropicLiveEvalRunner({
+  client: anthropicClient,
+  model: "claude-3-5-sonnet-latest"
+});
+```
+
+LangChain/LangGraph and MCP hosts can implement `AicfLiveEvalRunner` directly around
+their own runtime loop. AICF does not expose commit tools to any live eval runner.
+
+## CLI Live Evals
+
+The CLI is for intentional live checks only:
+
+```bash
+RUN_REAL_AICF_LIVE_EVALS=1 \
+OPENAI_API_KEY=... \
+aicf eval-live examples --cases cases.json --provider openai --model gpt-4.1-mini
+```
+
+Supported CLI providers are `openai`, `anthropic`, and `gemini`. The AI SDK path is
+available through TypeScript because host applications must supply `generateText` and a
+configured model object. The CLI refuses to run live evals unless
+`RUN_REAL_AICF_LIVE_EVALS=1` is set.
 
 ## Trace To Eval
 
-`createEvalCaseFromTrace()` creates a draft public-safe eval case from an
-OpenAI runtime result. It excludes raw user text and raw model output by
-default. Include model output only when the host has reviewed it for public
-safety.
+`createEvalCaseFromTrace()` creates a draft public-safe eval case from an OpenAI runtime
+result. It excludes raw user text and raw model output by default. Include model output
+only when the host has reviewed it for public safety.
 
 ## Promptfoo Export
 
 Promptfoo support is available from `ai-capability-framework/promptfoo`.
-`exportPromptfooSuite()` generates files only; it does not run Promptfoo. The
-default provider is `echo` so generated suites can be inspected without API
-keys.
+`exportPromptfooSuite()` generates files only; it does not run Promptfoo. The default
+provider is `echo` so generated suites can be inspected without API keys.
 
 The CLI command writes generated files when explicitly requested:
 
@@ -63,18 +100,17 @@ The CLI command writes generated files when explicitly requested:
 aicf export promptfoo examples --out ./promptfoo
 ```
 
-`importPromptfooResults()` maps basic Promptfoo JSON results back into live eval
-result summaries.
+`importPromptfooResults()` maps basic Promptfoo JSON results back into live eval result
+summaries.
 
 Capability-aware security packs have a focused Promptfoo export under
 `ai-capability-framework/security-packs`. That export generates red-team config
-templates with `echo` as the default provider and placeholders for host runtime
-targets. AICF does not run Promptfoo or call providers when exporting those
-files.
+templates with `echo` as the default provider and placeholders for host runtime targets.
+AICF does not run Promptfoo or call providers when exporting those files.
 
 ## EvalOps Exports
 
-`ai-capability-framework/evalops` provides dependency-free JSON exporters and
-importers for Braintrust-style and OpenAI-eval-style datasets/results. These
-helpers transform public-safe eval cases and summarized results only. They do
-not upload data, call external services, or require provider SDKs.
+`ai-capability-framework/evalops` provides dependency-free JSON exporters and importers
+for Braintrust-style and OpenAI-eval-style datasets/results. These helpers transform
+public-safe eval cases and summarized results only. They do not upload data, call
+external services, or require provider SDKs.