@dailephd/my-frontend-observer 0.8.1

package/docs/reports/v0.7-bounded-fidelity-context-prompt7.md

@@ -0,0 +1,243 @@
+# v0.7 Prompt 7 — Bounded Reference-Fidelity Projection and v0.6 Bounded-Agent-Context Integration
+
+**VERDICT: PASS_V0_7_BOUNDED_FIDELITY_CONTEXT_PROMPT7**
+
+## Repository / branch / heads
+
+- Repository: `my-frontend-observer` (path: `Z:\Users\newuser\Projects\my-frontend-observer`)
+- Branch: `implementation/v0.7-reference-bounded-context`, branched from the exact completed Prompt 6 HEAD
+- Starting HEAD (branch point, Prompt 6 report commit): `bc414f08156ce04f8c89244496de1699b14e302c`
+- Prompt 6 base HEAD confirmed to contain both required commits: `91f5e73` (implementation) and `bc414f0` (report), and the full completed Prompt 1–5 lineage — verified via `git log --oneline` before branching.
+- Implementation commit (this prompt): `013bc6c22b0f5df107d9f3896ba069c7f63783f2` — "Add v0.7 Prompt 7 bounded reference-fidelity projection and v0.6 bounded-agent-context integration"
+- Ending HEAD: the report commit that follows this file's commit.
+
+## Git status
+
+Preflight (`git status --short`) showed a clean working tree at the exact Prompt 6 report HEAD; `git stash list` showed exactly the one preserved Prompt 1 stray-fork-writes entry. The branch was created with `git checkout -b implementation/v0.7-reference-bounded-context` and ancestry verified with `git merge-base --is-ancestor bc414f0 HEAD`. No reset/clean/discard operation was used; the Prompt 1 stash was neither applied nor dropped. Post-implementation `git status --short` is clean except for this report file (staged and committed separately, per convention).
+
+## Tooling
+
+- Resolved latest published `@dailephd/my-dev-kit`: `1.12.3`, pinned exactly via `npx -y @dailephd/my-dev-kit@1.12.3`.
+- Fresh Prompt 7 repository index built under a repository-local, gitignored root: `.my-dev-kit-context/index-prompt7/` (59 files, 908 symbols indexed) — not reused from Prompt 1–6's indexes.
+
+## Prompt 1–6 contracts verified
+
+Read directly (source, not memory) before writing any code:
+
+- `src/domain/boundedAgentContext.ts` (v0.6 Batch 1/3) — the full frozen contract: `Adequacy`, `OmissionRecord`/`TruncationRecord`, `BoundedRuntimeTargetProjection`, `RuntimeStaticCorrelationRecord`, `CorrelationStatus`, all numeric bounds, and every already-exported structural validator.
+- `src/domain/boundedAgentContextProjection.ts` (v0.6 Batch 2 rescue) — the full `projectBoundedAgentContext` implementation: `clauseTier`/`isRequiredMembershipClause`/`evidenceTierForClauseResult` (the exact required/permitted/context tiering rule reused for fidelity), the required-first bounded target allocation, `boundedEvidenceForTarget`'s dedup/cap convention, `capOmissions`/`capTruncations`, and the adequacy-derivation rule (`anyRequiredLoss`/`anyOptionalLoss`, the `orderedRequired.length > 0 && ... >= orderedRequired.length` inadequate-threshold).
+- `src/domain/boundedAgentContextIdentity.ts` (v0.6 Batch 2) — `buildBoundedAgentContextRequestIdentity`'s exact pure-function-of-{sources, targetIds, projectionProfile} semantic view and canonicalize convention.
+- `src/domain/boundedAgentContextCorrelation.ts` (v0.6 Batch 3) — `deriveRuntimeStaticCorrelations`/`attachRuntimeStaticCorrelations`, confirmed untouched and reused exactly as-is (no correlation code was written or modified this prompt).
+- `src/domain/externalReferenceFidelity.ts` (Prompt 6) — `evaluateReferenceCandidateFidelity`'s exact result shapes (`ReferenceRequirementFidelityResult`, `ReferenceCandidateFidelityEvaluation`, `ReferenceFidelityState`, `ReferenceFidelityBlockReason`) and provenance fields.
+- `src/domain/externalReferenceRuntimeBinding.ts` (Prompt 5) — confirmed `boundRuntimeTargets`/binding identity is the exact stable v0.2 target name, sufficient as the runtime side of static correlation with no shortcut needed.
+- `src/domain/externalReferenceRequirements.ts` (Prompt 3) — `ReferenceRequirementAdequacy`, `AuthoredChangeScopeCategory`/`ExpectedDependentMode` (the v0.5 category vocabulary Prompt 3 reuses directly).
+- `src/domain/comparison.ts` — `isValidComparabilityResult`'s exact `incomparable ⇒ requires a blocking reason` invariant (relevant to constructing valid `compatibility` fixtures).
+
+No architecture blocker was hit; no `BLOCKED_ESCALATE_TO_FULL_STAGE_CONTEXT` condition applied at any point.
+
+## v0.6 bounded-context precedent
+
+`projectBoundedAgentContext` already tiers v0.5 contract-clause targets into required/permitted/context sets, allocates them into `MAX_RUNTIME_TARGETS` capacity with required-first priority, derives `omissions`/`truncations` from what got dropped, and computes `adequacy` purely from those two collections' `required` flags — this exact machinery, not a redesign, is what Prompt 7's fidelity input feeds into.
+
+## Chosen integration owner
+
+`projectBoundedAgentContext` itself, extended with one new optional input (`fidelity?: ReferenceCandidateFidelityEvaluation`, `fidelityRequired?: boolean`) — not a separate `VisualAgentContext`/`VisualPromptPacket`/`ReferencePromptBuilder`, and not a pure post-hoc "attach" step in the shape `attachRuntimeStaticCorrelations` uses. The attach-step shape was considered and rejected: fidelity-relevant runtime targets must compete fairly for `MAX_RUNTIME_TARGETS` capacity and receive full `BoundedRuntimeTargetProjection` treatment (geometry/visibility/overflow/scrollOwner/screenshotRef) through the exact existing per-target assembly code, which an attach-only step run after target allocation has already finished could never produce. A new pure sibling module, `domain/referenceFidelityProjection.ts` (`projectReferenceFidelity`), derives the bounded/prioritized fidelity content plus the target-id/omission/truncation contributions that `projectBoundedAgentContext` folds into its own existing pipeline before allocation, capping, and adequacy computation run.
+
+## Fidelity projection model
+
+```ts
+// domain/referenceFidelityProjection.ts
+function projectReferenceFidelity(
+  fidelity: ReferenceCandidateFidelityEvaluation,
+  options?: { required?: boolean }, // defaults to true
+): {
+  projection: BoundedReferenceFidelityProjection;
+  requiredTargetIds: string[];
+  permittedTargetIds: string[];
+  omissions: OmissionRecord[];
+  truncations: TruncationRecord[];
+};
+
+// domain/boundedAgentContext.ts - additive
+interface BoundedReferenceFidelityProjection {
+  referenceId: string; referenceRequestId: string;
+  candidateObservationId: string; candidateRequestId: string;
+  adequacy: ReferenceRequirementAdequacy;   // reused verbatim from Prompt 3
+  compatibility?: ComparabilityResult;      // reused verbatim from Prompt 4
+  state: ReferenceFidelityState;            // reused verbatim from Prompt 6
+  blockedBy?: ReferenceFidelityBlockReason; // reused verbatim from Prompt 6
+  mismatches: ReferenceRequirementFidelityResult[];       // bounded, prioritized non-pass
+  protectedContext: ReferenceRequirementFidelityResult[]; // bounded passing protected/preserved
+}
+```
+
+`ReferenceRequirementFidelityResult` (Prompt 6's own type) is reused as the array element type verbatim — no duplicated or re-flattened field set.
+
+## Selection policy
+
+Only non-`pass` Prompt 6 requirement results are ever candidates for `mismatches` — passing requirements are never dumped by default (behavior D). Each candidate is classified into a tier by category/mode, reusing `boundedAgentContextProjection.ts#clauseTier`'s exact rule (duplicated as `fidelityRequirementTier`, not imported, per the established per-module small-helper convention): `protected`/`preserved` → `required`; `expected-dependent`/`'required'` → `required`; `expected-dependent`/`'permitted'` and `requested` → `optional`. Passing `protected`/`preserved` results are surfaced separately as `protectedContext` (disjoint from `mismatches` — a *failing* protected/preserved requirement already appears in `mismatches` at the highest priority, never duplicated).
+
+## Priority policy
+
+1. `fail` + `required` tier
+2. `unavailable` + `required` tier
+3. any other non-`pass` (`optional`-tier) result
+
+Within one priority class, Prompt 6's own authored requirement order is preserved (a stable sort by rank only). The reported `mismatches` array is in priority order (highest first) — verified this is genuinely priority-first, not restored to authored order, by a dedicated test that caught and fixed an initial implementation bug (see Tooling incidents).
+
+## Cap values
+
+`MAX_FIDELITY_MISMATCHES = 15` and `MAX_FIDELITY_PROTECTED_CONTEXT = 10` (reusing `MAX_RELATIONSHIP_EVIDENCE_PER_TARGET`'s value) — both judgment-call bounds in the same spirit as v0.6 Batch 1's own frozen caps (no measured fixture corpus exists yet for either concept, matching that section's own documented rationale).
+
+## Omission/truncation behavior
+
+Reuses `OmissionRecord`/`TruncationRecord` wholesale — no second reporting model. Exceeding `MAX_FIDELITY_MISMATCHES` records `{subject: 'fidelity-mismatches', limit, actualCount, required}` plus one `{subject: 'fidelity-mismatch:<requirementId>', reason: 'required-evidence-lost-by-bound', required: true}` omission per dropped required-tier mismatch. Exceeding `MAX_FIDELITY_PROTECTED_CONTEXT` records a truncation with `required: false` always (confirmatory/passing context is never "required loss"). These records are prepended into `projectBoundedAgentContext`'s own `omissions`/`truncations` arrays before its existing `capOmissions`/`capTruncations` aggregate-cap calls and its existing adequacy computation run — fidelity loss participates in the exact same `anyRequiredLoss`/`anyOptionalLoss` rule every other evidence source already uses, never a separate adequacy code path.
+
+## Adequacy behavior
+
+A `not-evaluated` fidelity always records an explicit omission (`{subject: 'fidelity', reason: 'unsupported-or-unavailable', required, detail}`), where `required` defaults to `true` — supplying a fidelity evaluation to be projected at all is itself the signal that the task depends on it, mirroring `CorrelationTargetInput.required`'s existing v0.6 convention. A `required: true` fidelity omission prevents `adequacy.state` from remaining `'adequate'` (verified: it becomes `'partial'` in the tested scenario, since v0.6's own inadequate-threshold is scoped to runtime-target unavailability specifically — an honest, non-`'adequate'` state either way, never falsely `'adequate'`). A `required: false` omission (`fidelityRequired: false`) never degrades adequacy past `'partial'`, matching v0.6's own pre-existing "optional-only loss never means inadequate" rule exactly — unchanged, not redefined. A `pass` fidelity result contributes no omissions/truncations and never degrades adequacy (verified by a dedicated test).
+
+## Not-evaluated fidelity behavior
+
+Preserved exactly as Prompt 6 reported it — `artifact.fidelity.state`/`.blockedBy` are a direct pass-through of Prompt 6's own values, with `mismatches`/`protectedContext` both empty (nothing to select from an empty `requirementResults`). Verified this is never silently converted into "no fidelity problems": a dedicated test confirms `adequacy.state !== 'adequate'` whenever a `not-evaluated`/`required` fidelity is supplied.
+
+## Per-target organization
+
+Every fidelity mismatch's `boundRuntimeTargets` (Prompt 5/6's own field, never truncated) is added to `projectBoundedAgentContext`'s existing `requiredTargetIds`/`permittedTargetIds` sets before its existing bounded allocation runs, so those runtime targets receive full `BoundedRuntimeTargetProjection` treatment through the unmodified existing per-target assembly code (verified: a target named only by a fidelity mismatch appears in `artifact.targets` with its own `geometry`). Reference regions are never used as a target-selection or correlation key — only the already-bound stable v0.2 runtime target id is.
+
+## Multi-target relationship representation
+
+A `region-relationship` mismatch's `boundRuntimeTargets` array (already carrying both bound targets from Prompt 6) is used as-is — both targets are added to the required/permitted set, so both appear in `artifact.targets`. Verified by a dedicated test with a two-target relationship failure, confirming both target ids are present.
+
+## Static-correlation reuse
+
+Entirely unchanged — `deriveRuntimeStaticCorrelations`/`attachRuntimeStaticCorrelations` were not modified and are not called from any new code this prompt introduces. `BoundedRuntimeTargetProjection.targetId` and `RuntimeStaticCorrelationRecord.runtimeTargetId` already share the same stable v0.2 identity a fidelity mismatch's `boundRuntimeTargets` also uses, so a caller (Prompt 8) joins fidelity, target, and correlation evidence by that one shared id without this module ever reading source, running my-dev-kit, or choosing among ambiguous candidates itself.
+
+## Ambiguous/unavailable correlation behavior
+
+Unaffected — `RuntimeStaticCorrelationRecord`'s frozen `status: 'ambiguous' ⇒ candidates.length >= 2` invariant is untouched (no correlation code was written), and `status: 'unavailable'` for a runtime target never causes a fidelity mismatch naming that same target to be dropped: the two evidence kinds are attached independently (fidelity via `artifact.fidelity`, correlation via the separate, caller-driven `attachRuntimeStaticCorrelations` step) and neither erases the other.
+
+## Provenance
+
+Every included mismatch remains traceable to the reference (`sources.referenceId`/`referenceRequestId`, new), the requirement (`requirementId`, `category`, `subject` — naming its reference region(s)), the Prompt 5 binding (`boundRuntimeTargets`), the candidate (`sources.observationIds`), and the full Prompt 6 evidence (`referenceValue`/`candidateRawValue`/`candidateValue`/`delta`/`tolerance` or `expectedRelationship`/`actualRelationship`). No raw image bytes are ever embedded (fidelity carries only identifiers and numeric/categorical evidence, never pixels — verified by inspecting the type shape, which has no byte-array field anywhere). No source-ownership field (`sourceOwner`/`sourceFile`/`component`/`symbol`/`causedBy`) is ever produced.
+
+## Identity impact
+
+`buildBoundedAgentContextRequestIdentity` gained a final optional `fidelity?: unknown` parameter — omitted (never `null`) from the hashed semantic view when absent, verified by a dedicated test asserting `buildBoundedAgentContextRequestIdentity(sources, ids, profile)` and the same call with an explicit trailing `undefined` produce byte-identical hashes. When present, the caller's already-derived, bounded `BoundedReferenceFidelityProjection` (not the raw Prompt 6 evaluation) is hashed, so identity changes exactly when the content a caller would actually receive changes — verified by a test confirming identical fidelity content produces the identical `contextRequestId` and changed fidelity content changes it. `sources.referenceId`/`referenceRequestId` follow the identical omit-when-absent convention (also tested). **An initial implementation mistake was caught and fixed before committing**: the first draft defaulted these two new `sources` fields to `?? null` (the pattern used for pre-existing fields like `comparisonId`), which would have broken every historical hash by adding two new `null`-valued keys to the semantic view unconditionally. This was caught immediately (before any test ran) by re-reading the identity module's own doc comment about the omit-vs-null distinction, and fixed to the correct omit-when-`undefined` pattern; the full 927-test pre-existing suite (including this exact area) was then run and passed unchanged, confirming no historical hash regression reached a commit.
+
+## Schema-version decision
+
+No bump — `BOUNDED_AGENT_CONTEXT_SCHEMA_VERSION` stays `1.0.0`. Every new field (`BoundedAgentContextSourceReferences.referenceId`/`referenceRequestId`, `BoundedAgentContextArtifact.fidelity`) is additive and optional; a pre-Prompt-7 artifact/consumer remains fully valid and behaviorally unchanged with all of them absent, matching the exact precedent `correlations?` already established without a version bump in v0.6 Batch 3.
+
+## Persistence decision
+
+**None.** `projectBoundedAgentContext` and `projectReferenceFidelity` both remain pure, programmatic, in-memory functions — no new writer/reader, no new artifact family. This mirrors Prompt 6's own "no persisted fidelity artifact" decision and v0.6's existing "bounded agent context is library-only" architecture. No `BLOCKED_ESCALATE_TO_FULL_STAGE_CONTEXT` condition was triggered, since nothing about this integration required persistence to be meaningful.
+
+## Public API changes
+
+Additive exports from `src/index.ts`:
+- `domain/referenceFidelityProjection.js`: `projectReferenceFidelity`, `ProjectReferenceFidelityOptions`, `ProjectReferenceFidelityOutput`.
+- `domain/boundedAgentContext.js`: `BoundedReferenceFidelityProjection` (type), `isValidBoundedReferenceFidelityProjection`, `MAX_FIDELITY_MISMATCHES`, `MAX_FIDELITY_PROTECTED_CONTEXT`.
+- `domain/boundedAgentContextProjection.js`: `ProjectBoundedAgentContextInput` gained `fidelity?`/`fidelityRequired?` (type-level, no new export name).
+- `domain/externalReferenceRequirements.js`: `isValidReferenceRequirementAdequacy` (new defense-in-depth validator for the already-frozen Prompt 3 `ReferenceRequirementAdequacy` shape, needed by `boundedAgentContext.ts`'s own new validator).
+- `domain/externalReferenceFidelity.js`: `isValidReferenceRequirementFidelityResult` (new defense-in-depth validator for the already-frozen Prompt 6 `ReferenceRequirementFidelityResult` shape, for the same reason).
+
+## CLI decision
+
+None added. v0.6 bounded agent context has never had a CLI surface, and this prompt does not introduce one — the bounded-context/fidelity integration remains library-only, exactly as instructed. Prompt 8 is expected to become the first concrete consumer of `projectBoundedAgentContext`'s (now fidelity-aware) programmatic output. `docs/COMMANDS.md` was not touched.
+
+## Files changed
+
+New:
+- `src/domain/referenceFidelityProjection.ts`
+- `tests/unit/referenceFidelityProjection.test.ts`
+
+Modified:
+- `src/domain/boundedAgentContext.ts` (new constants/types/validator/field, additive)
+- `src/domain/boundedAgentContextIdentity.ts` (new optional trailing `fidelity` parameter, `sources.referenceId`/`referenceRequestId` inclusion)
+- `src/domain/boundedAgentContextProjection.ts` (new optional `fidelity`/`fidelityRequired` input, wiring into target allocation/omissions/truncations/adequacy/identity/output)
+- `src/domain/externalReferenceFidelity.ts` (additive `isValidReferenceRequirementFidelityResult` validator)
+- `src/domain/externalReferenceRequirements.ts` (additive `isValidReferenceRequirementAdequacy` validator)
+- `src/index.ts` (public export surface for the above)
+- `docs/ARCHITECTURE.md`, `docs/CONTRACTS.md`, `docs/WORKFLOWS.md`
+- 5 existing test files extended with Prompt 7 coverage (see Tests below)
+
+## Tests
+
+981 unit tests total (927 pre-existing + 54 new), all pure domain-level tests — zero Chromium launches for this prompt's own logic.
+
+- `tests/unit/referenceFidelityProjection.test.ts` (16 tests): one/several/over-cap failures with deterministic truncation and per-mismatch required omissions, failed-before-unavailable-before-optional priority, passing requirements omitted by default, fidelity-pass compact output, not-evaluated blocker preservation (both `required: true` and `required: false`), bound runtime target identity preservation (single- and two-target), protected/preserved context surfacing and its own bound/truncation, expected-dependent required/permitted tiering, determinism, and input immutability.
+- `tests/unit/boundedAgentContextProjection.test.ts` (+20 tests): no-fidelity backward compatibility, identity changing only with semantically-present/different fidelity content, fidelity-derived targets appearing in `targets` with full geometry (single- and two-target relationship), not-evaluated-fidelity adequacy degradation (required and non-required), passing-fidelity adequacy non-degradation, cross-artifact `candidateObservationId` coherence rejection, input immutability, determinism, and full artifact structural validity.
+- `tests/unit/boundedAgentContextIdentity.test.ts` (+6 tests): omitting `fidelity`/`referenceId`/`referenceRequestId` produces byte-identical identity to before the parameters existed; supplying/changing them changes identity appropriately.
+- `tests/unit/boundedAgentContext.test.ts` (+9 tests): `fidelity` field acceptance/rejection on the top-level artifact validator, `sources.referenceId`/`referenceRequestId` acceptance, and a dedicated `isValidBoundedReferenceFidelityProjection` describe block (valid minimal/not-evaluated projections, exact-cap/one-over-cap for both `mismatches` and `protectedContext`, malformed-entry rejection, unavailable-without-reasonCode rejection, non-object rejection).
+- `tests/unit/externalReferenceRequirements.test.ts` (+3 tests) and `tests/unit/externalReferenceFidelity.test.ts` (+8 tests): the two new defense-in-depth structural validators.
+
+## Validation results
+
+All commands run from the repository root, after the implementation commit:
+
+- `npm run typecheck` — pass, zero errors.
+- `npm run lint` — pass, zero errors/warnings (one `no-unused-vars` was caught and fixed during development — see Tooling incidents).
+- `npm test` — 49 test files, 981 tests, all pass.
+- `npm run build` — pass, clean `tsc` compile.
+- `npm run check:docs` — pass (17 required files present, `ROADMAP.md` format intact — no implementation batches added).
+- `git diff --check` — exit 0, no whitespace errors (only benign LF→CRLF Windows-checkout notices).
+- `npm pack --dry-run` — pass; `dist/domain/referenceFidelityProjection.{js,d.ts,js.map}` confirmed present in the tarball listing (public exports changed, so this was run per the task's requirement).
+- `npm run test:security` — pass (5 + 63 = 68 tests), run per established repository regression policy.
+- `npm run test:browser` — pass (9 files, 120 tests, real Chromium), run as full regression confirmation. No flaky-test incident occurred on this run (all 120 passed cleanly on the first attempt).
+
+## Regression results
+
+- Prompt 1 external-reference foundation: unaffected — `externalReference.ts` untouched.
+- Prompt 2 regions/relationships: unaffected — untouched.
+- Prompt 3 requirements/tolerances/adequacy: unaffected in behavior — `externalReferenceRequirements.ts`'s only change is one new additive validator function; `deriveReferenceRequirementAdequacy`'s own logic is untouched, and every existing test for it still passes unchanged.
+- Prompt 4 compatibility: unaffected — untouched.
+- Prompt 5 binding: unaffected — untouched.
+- Prompt 6 fidelity: unaffected in behavior — `externalReferenceFidelity.ts`'s only change is one new additive validator function; `evaluateReferenceCandidateFidelity`'s own logic is untouched, and every existing test for it still passes unchanged.
+- v0.4 comparison/relationship behavior: unaffected — untouched.
+- v0.5 contracts/evaluation: unaffected — untouched.
+- v0.6 bounded context/correlation: unaffected when fidelity is absent — verified explicitly by a dedicated backward-compatibility test (behavior K) confirming no `fidelity` key appears and `sources.referenceId` is `undefined`; every pre-existing `boundedAgentContextProjection.test.ts`/`boundedAgentContext.test.ts`/`boundedAgentContextIdentity.test.ts`/`boundedAgentContextCorrelation.test.ts` test continues to pass unchanged, including the IMP-SHARED/IMP-B rescue-regression suite.
+- Full unit (981/981), browser (120/120), and security (68/68) suites all pass with zero regressions.
+
+## Browser-flake incidents
+
+None this prompt. The single `test:browser` run completed cleanly (120/120) on the first attempt.
+
+## Security impact
+
+- No new external input surface — `projectBoundedAgentContext`/`projectReferenceFidelity` are pure, in-memory functions with no file, network, or browser access; no CLI/config-file surface was added.
+- `test:security` (policy + real-Chromium adapter tests) re-run and passing, confirming no regression to the existing safety/navigation policy surface (untouched by this prompt).
+
+## Documentation changes
+
+- `docs/CONTRACTS.md` — new "v0.7 Prompt 7 bounded reference-fidelity projection and v0.6 bounded-agent-context integration" section (integration-owner rationale, full type shapes, selection/priority policy, cap values, omission/truncation/adequacy behavior, not-evaluated handling, per-target/multi-target representation, static-correlation reuse, provenance, identity/schema/persistence/CLI decisions).
+- `docs/ARCHITECTURE.md` — new paragraph in the "Current v0.6 architecture" continuation describing the Prompt 7 module additions and their reuse of v0.6's existing tiering/allocation machinery.
+- `docs/WORKFLOWS.md` — "Current bounded agent context workflow" extended with a "v0.7 Prompt 7 addition" subsection and flow diagram.
+- `docs/COMMANDS.md` — not touched (no CLI surface change this prompt, as expected).
+
+## Tooling incidents
+
+Two implementation mistakes were caught and fixed during development, before any commit:
+
+1. **Identity backward-compatibility bug**: the first draft of the `sources.referenceId`/`referenceRequestId` semantic-view inclusion in `boundedAgentContextIdentity.ts` used the `?? null` pattern from the pre-existing fields, which would have silently changed every historical `contextRequestId` hash. Caught by re-reading the module's own doc comment about the omit-vs-null convention before running any test; fixed to the correct omit-when-`undefined` pattern.
+2. **Priority-ordering bug**: the first draft of `projectReferenceFidelity` restored Prompt 6's original authored order for the *entire* retained `mismatches` array after priority-based selection, rather than preserving priority order in the output. Caught immediately by a failing test (`failed-before-unavailable priority...`) during the initial test run; fixed by reporting `mismatches` in the already-priority-sorted order directly.
+
+No orchestrator was invoked (direct-implementation mode used throughout, consistent with Prompts 2–7); no background/speculative subagent writes occurred; the Prompt 1 stray-fork-writes stash remains untouched, unapplied, and unmined as precedent.
+
+## Out-of-scope confirmation
+
+This prompt implements no coding-agent invocation, no prompt-platform integration, no source editing, no rerender/retry orchestration, no autonomous correction, no final v0.7 review lifecycle, no baseline approval, no viewer, and no annotation. It never modifies `my-dev-kit-orchestrator` or any my-dev-kit product code, never invents source ownership, never reads source files itself, and never runs my-dev-kit as product behavior — `deriveRuntimeStaticCorrelations`/`attachRuntimeStaticCorrelations` remain the caller's own, entirely unmodified, separate step.
+
+## Known limitations
+
+- `MAX_FIDELITY_MISMATCHES`/`MAX_FIDELITY_PROTECTED_CONTEXT` are judgment-call bounds with no measured fixture corpus behind them yet, matching the same documented limitation v0.6 Batch 1's own original bounds carried.
+- Fidelity's `required`/`optional` tiering is derived solely from the requirement's authored `category`/`expectedDependentMode` (reusing v0.6's exact `clauseTier` rule) — there is no separate, fidelity-specific "focus" filter (analogous to `focusTargetIds`) for selecting which reference regions matter; every non-passing selected requirement is automatically a mismatch candidate, which is judged sufficient since Prompt 3's own requirement-selection discipline already scopes the requirement set to what the user explicitly cares about.
+- No CLI surface exists for inspecting a fidelity-aware bounded context outside of direct programmatic use, consistent with v0.6's existing library-only architecture and this prompt's explicit CLI-decision guidance.
+
+## Remaining risks
+
+- None identified that block this prompt's own scope. The primary forward consideration for Prompt 8 (controlled end-to-end coding-agent correction workflow) is how it will actually invoke `deriveRuntimeStaticCorrelations` using the runtime target ids surfaced by `artifact.fidelity.mismatches[].boundRuntimeTargets`, and how it will present the joined fidelity+target+correlation view (the "TARGET / FAILED REQUIREMENTS / RUNTIME TARGET / STATIC CORRELATION" example format) to a coding agent — flagged for that prompt's own precedent review and design, not preempted here.
+
+## Exact next action
+
+v0.7 Prompt 8 — controlled end-to-end external-reference coding-agent correction workflow, correction iteration, contract composition, and real-browser proof.