# Value Scenario Verify

> Verify an adopted finite scenario set at the authorized completed value-phase boundary using the project's existing real-path runner, with a safe oracle-sensitivity challenge, preserved attempts and canonical evidence. Not a runner, repair loop or early check.

- Skill: `prometheus-ags/value-scenario-verify` (Agent Skill)
- Install (CLI): `npx get-skill add prometheus-ags/value-scenario-verify`
- Raw SKILL.md: https://api.skillmd.com/api/skills/prometheus-ags/value-scenario-verify/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: Prometheus-AGS (https://skillmd.com/u/prometheus-ags)
- Updated: 2026-11-18
- Page: https://skillmd.com/skills/prometheus-ags/value-scenario-verify

---


# Value scenario verification

Invoke the `value-scenario-verify` skill with a contract reference. This
instruction-only procedure is steps 1–4 of the B4 sequence (admit, freeze, run the
boundary packet once, record) and the targeted rerun of an authorized B5 repair,
as defined once in `kbd-process-orchestrator/references/boundaries.md`. It routes
an adopted boundary packet through existing tools. It does not
intercept commands and grants no permission the host does not provide.

Emit `Starting value-scenario-verify — <phase>` before work. Emit completion with
the actual scoped verdict only after observations are recorded. BLOCKED or
NOT_EXERCISED is never a completed acceptance claim.

## Admit the boundary

Resolve the canonical phase and run, the latest non-superseded contract binding,
and the contract's scenario IDs, exclusions, current candidate, oracle, evidence
invalidation keys, budgets, owned resources and cleanup. Reconcile uncertain
effects from earlier attempts before any retry.

Every agreed production obligation must be complete. A task, hour, commit,
checkpoint, reviewer request or compiler problem is not this boundary, and
unfinished production prevents running it. Readiness for implementation is not
permission to test: run the readiness check, then require separate current
authority for this boundary and its effects. If the frozen contract needs a
material amendment (including `status.implementationComplete`), use the existing
adoption path with `--supersedes`; never edit a bound contract or forge approval.

```
node "<package-root>/scripts/kbd-phase-readiness-check.mjs" --phase "<phase>"
```

Then record the owner's boundary authorization once, before the first attempt
(B4; `--boundary B5` for an authorized repair). Closure lists runner output under
`boundaryPacket.runnerOutputGlobs` that is older than this event (report only):

```
node "<package-root>/scripts/kbd-boundary-authorize.mjs" --phase "<phase>" --authorizer "<who>"
```

Replace `<package-root>` with the absolute root of the loaded mini package; keep
the consumer working directory and quote paths.

## Run the smallest adequate real path

Use the exact commands in `boundaryPacket.commands`, once, in order, through the
project's existing runner (for example `bdd-cucumber-js` features on Node). Use
the real process, network, filesystem or CLI boundary: a Node/API or CLI journey
needs no browser. A mock that replaces the behavior under test is a substituted
boundary, recorded as such. A missing runner, permission, fixture, identity or
isolation is BLOCKED; never install tools or silently skip an adopted case.

Invoke each packet command exactly as given, once: no appended commands, pipes,
`echo` wrappers or retries. The runner's receipt records its own exit status and
observations. Read receipts, results and evidence files with file-reading tools;
do not run additional commands to inspect, re-run or summarize them. Any command
outside the packet is outside this boundary's authority.

Freeze source, configuration, fixture and candidate digests before running.
Assert the contract's externally meaningful observation against an independent
source of truth. Then challenge each material oracle family safely: run the
agreed plausible false positive or negative control (for example a deliberately
wrong expected value or a mutated copy under the scratch fixture root) and
confirm the real assertion fails. Never mutate production sources or shared
state for this. A disconnected `return false` step proves nothing about
sensitivity, and process exit zero alone is not an observation.

## Retain every material attempt

Save original runner output and observations before deriving any verdict. Record
contract/run/phase/scenario/assertion identity, expected-truth source, digests,
actual argv, what was attempted and observed, real versus substituted boundaries,
failed and successful attempts, consumed-budget high-water marks, repair lineage,
uncertain effects, restoration and cleanup.

| Situation | Disposition |
|---|---|
| Real exercised product oracle unmet | FAIL, with the observation |
| Required assertion never exercised, disabled or always true | NOT_EXERCISED; cannot pass |
| Stale candidate, configuration, oracle or evidence | BLOCKED; keep the stale attempt |
| Runner, prerequisite, fixture, permission or isolation unavailable | BLOCKED, not a product failure |
| Cleanup failed or effects uncertain | BLOCKED; reconcile before retry |
| Correct scoped observation, effective negative control, limits and cleanup met | PASS within that scope |

Never overwrite an earlier failure with a later green receipt. Budget exhaustion
checkpoints BLOCKED without dropping mandatory constraints. An authorized repair
(B5) finishes its complete implementation batch before one targeted reverification
of only the affected scenarios and their negative controls, consuming
`budgets.repairAttempts`;
preserve prior consumption and re-evaluate affected evidence. Start no automatic
repair loop, new task, new phase, publication or successor.

## Return evidence to the existing writer

Write the existing `boundary-results.json` the mini evaluator already reads:
`phase`, `projectId`, `runId`, `contractDigest`, `sourceDigests`, `scenarios`
(each with `id`, `status`, `attempted`, `observed`, `evidence`), `executedBy`
(`harness`, `version`, `model` of the session that ran the packet) and
`budgetConsumption` (with its source and measured/estimate/unknown classes). Keep
assertions and negative-control receipts linked from `evidence`. Do not derive
fields from an exit code, and add no other ledger or schema field. Then (it also writes `closure.json` and
`closure-packet.md`):

```
node "<package-root>/scripts/kbd-phase-close-eval.mjs" --phase "<phase>"
```

Only that evaluator closes a bound phase; FAIL or BLOCKED stays recorded and the
phase stays open. Unsupported terminal vocabulary (cancelled, deferred, "closed
unmet") stays refused and is never mapped to PASS.

Report these separately: authored implementation, measured contract acceptance,
demonstrated runtime value, unresolved gaps, and release authority. Independent
final review stays separate.

