git:20260806.b506b65 to git:20261008.193dd3e

5 added, 2 removed. Audit A to A.

---

name: mocking-strategy-roster

description: Use when an agent must mock a downstream HTTP/event dependency for an integration test and needs to know WHICH mocking strategy and stack adapter to use. Resolves the mocking strategy (Microcks by default, overridable to an in-process library) and the stack, then points to the concrete `mocking-<strategy>-<stack>` adapter. Loaded by the mock-integration-worker. No agent hardcodes a mocking approach — it resolves it here.

---

# Mocking Strategy Roster (stack + strategy agnostic)

The single place that resolves **how** a downstream dependency is mocked for an

integration test. No agent and no worker hardcodes "spin up Microcks" or "use

Moq". They resolve the pair `(strategy x stack)` here, then load the matching

adapter.

This mirrors `resolving-stack-commands`: the roster owns the routing table; the

adapters own the concrete wiring.

## Two orthogonal axes

- **Strategy** — WHICH mocking approach. Exclusive choice:

- `microcks` (DEFAULT, overridable) — mock the downstream from its

OpenAPI/examples contract via a container.

- `inprocess` — an in-process test double injected into the test host DI.

- **Stack** — WHICH toolchain, detected via `resolving-stack-commands`.

The two axes never mix inside one file. Each `(strategy x stack)` pair is one

thin adapter.

## Resolving the strategy (override cascade)

Read the strategy by tool-call, never from recall. Precedence, first writer wins:

1. **Explicit prompt** — the run prompt names a strategy/library

- (e.g. "mock with Moq", "use Microcks here"). Highest priority.

+ (e.g. "mock with Moq", "mock with respx", "use Microcks here"). Highest priority.

2. **Repo instruction file** — read

`.github/instructions/skraft.instructions.md` field

`testing.mocking.strategy` (and `testing.mocking.library` when

`strategy: inprocess`). Read ONLY the `testing.mocking.*` namespace.

3. **Default** — `microcks`.

Read the file with a tool call (it is a fact-that-must-be-true, S7). Do not

assume its contents. If the file is absent, fall through to the default.

When `strategy: inprocess` resolves but no `library` is named, the chosen

adapter's Library table decides — its rows are ordered by priority (top =

highest). The roster does not restate the order.

## Detection -> adapter

Detect the stack from markers at the repo root (delegate to

`resolving-stack-commands`), then resolve the concrete adapter from the matching

`mocking-<strategy>-<stack>` skill:

|---|---|---|---|

Adding a stack = add the `mocking-<strategy>-<stack>` adapter(s) and the row(s)

here, with zero edits to the worker or the orchestrator.

## Unknown value -> stop, never guess

If the resolved strategy is outside `{microcks, inprocess}`, or the library is

- outside `{moq, fakeiteasy, nsubstitute}` when `strategy: inprocess`, or the

+ not a row of the resolved adapter's Library table when `strategy: inprocess`

+ (.NET: `moq`, `fakeiteasy`, `nsubstitute`; Python: `respx`, `responses`, `fake`), or the

detected stack has no adapter, STOP and emit a structured blocker. Never invent

a wiring:

```yaml

status: blocked

type: unsupported_mocking_strategy # | unsupported_mocking_library | unsupported_stack

message: No mocking adapter for the resolved (strategy x stack)

context:

strategy: kafka-mock

stack: dotnet

source: prompt | skraft.instructions.md | default

```

## Contract for callers

- Resolve `(strategy x stack)` here; do not embed a mocking approach in the worker.

- Load the resolved adapter and apply its recipe.

- Adding a strategy or stack = add an adapter and a row here, zero edits elsewhere.