@riddledc/riddle-proof-packs 0.4.5 → 0.4.7

package/dist/index.js

@@ -1,9 +1,14 @@
+import {
+  createDurableCandidatePatchPlan,
+  createDurableCandidatePatchPlanArtifacts,
+  formatDurableCandidatePatchPlanMarkdown
+} from "./chunk-VFPSPQD7.js";
 import {
   createHumanReviewPacketArtifacts,
   findHumanReviewPacket,
   formatHumanReviewPacketMarkdown,
   requireHumanReviewPacket
-} from "./chunk-XQ2N4EYF.js";
+} from "./chunk-SAE6HFAG.js";
 
 // src/pack-data.ts
 import { normalizeRiddleProofProfile } from "@riddledc/riddle-proof";
@@ -1624,6 +1629,185 @@ var playback_sync_default = {
   }
 };
 
+// packs/neon-step-sequencer/profiles/ratchet-loop-approved-candidate.json
+var ratchet_loop_approved_candidate_default = {
+  version: "riddle-proof.profile.v1",
+  name: "neon-step-sequencer-ratchet-loop-approved-candidate",
+  target: {
+    route: "/games/drum-sequencer?song=monkberry-moon-delight-tab&mix=profile&view=trainer&instrument=bass",
+    viewports: [
+      {
+        name: "desktop",
+        width: 1440,
+        height: 1e3
+      }
+    ],
+    timeout_sec: 360,
+    wait_for_selector: ".drum-sequencer h1",
+    setup_actions: [
+      {
+        type: "window_eval",
+        label: "capture-neon-contract",
+        timeout_ms: 1e4,
+        store_return_to: "__neonMixProof.contract",
+        script: "const contract=window.__NEON_MIX_PROOF__; const diagnostic=contract?.captureDiagnostic?.(); window.__neonMixProof={...(window.__neonMixProof||{}),contract:{available:Boolean(contract),diagnostic}}; return window.__neonMixProof.contract;",
+        return_summary_fields: [
+          {
+            path: "available"
+          },
+          {
+            path: "diagnostic.selectedSong.selectedSong"
+          }
+        ]
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.contract.available",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
+      {
+        type: "window_call",
+        label: "apply-approved-claim-candidate",
+        path: "__NEON_MIX_PROOF__.runRatchetLoop",
+        args: [
+          {
+            intent: "turn the chord part down a little",
+            strategy: "mix-level-search",
+            focusTracks: [
+              "bass",
+              "chord",
+              "guitar",
+              "rhythmSynth"
+            ],
+            maxIterations: 6,
+            monitorProfile: "smallSpeaker",
+            restore: true,
+            applyBest: true,
+            approval: {
+              mode: "mixing_canon_surrogate",
+              approvedBy: "codex",
+              basis: "subtle level reduction after objective receipts pass; this keeps development moving while preserving a listening-review caveat"
+            }
+          }
+        ],
+        store_return_to: "__neonMixProof.approvedCandidateLoop",
+        capture_return: true,
+        timeout_ms: 24e4,
+        return_summary_fields: [
+          {
+            path: "ok"
+          },
+          {
+            path: "status"
+          },
+          {
+            path: "best.claimVerdict.status"
+          },
+          {
+            path: "best.claimCandidate.action.track"
+          },
+          {
+            path: "appliedCandidateReceipt.ok"
+          },
+          {
+            path: "humanReviewPacket.status"
+          },
+          {
+            path: "humanReviewPacket.request.approval.mode"
+          },
+          {
+            path: "humanReviewPacket.ranking.role"
+          }
+        ]
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.approvedCandidateLoop.ok",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.approvedCandidateLoop.appliedCandidateReceipt.ok",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.approvedCandidateLoop.humanReviewPacket.status",
+        expected_value: "candidate_applied_for_listening_review",
+        timeout_ms: 1e4
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.approvedCandidateLoop.humanReviewPacket.request.candidateActionsAreTransient",
+        expected_value: false,
+        timeout_ms: 1e4
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.approvedCandidateLoop.humanReviewPacket.guardrails.approvedCandidateApplied",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
+      {
+        type: "screenshot",
+        label: "neon-step-sequencer-ratchet-loop-approved-candidate",
+        mode: "viewport"
+      }
+    ]
+  },
+  checks: [
+    {
+      type: "route_loaded",
+      expected_path: "/games/drum-sequencer"
+    },
+    {
+      type: "selector_visible",
+      selector: ".drum-sequencer h1"
+    },
+    {
+      type: "no_horizontal_overflow"
+    },
+    {
+      type: "no_fatal_console_errors"
+    }
+  ],
+  artifacts: [
+    "screenshot",
+    "console",
+    "dom_summary",
+    "proof_json"
+  ],
+  baseline_policy: "invariant_only",
+  failure_policy: {
+    environment_blocked: "neutral",
+    proof_insufficient: "review",
+    needs_human_review: "review",
+    product_regression: "fail"
+  },
+  metadata: {
+    pack_id: "neon_step_sequencer",
+    pack_public_name: "Neon Step Sequencer Pack",
+    evidence_role_pattern: "interaction_snapshots",
+    purpose: "Run a bounded loop, use an explicit operator-approval surrogate, apply the supported claim candidate, and preserve a listening-review packet.",
+    required_receipts: [
+      "ratchet loop returns ok",
+      "a supported claim candidate is selected",
+      "approved candidate application receipt is captured",
+      "compact human-review packet is captured",
+      "ranking remains review-order only",
+      "listening-review caveat remains explicit"
+    ],
+    does_not_prove: [
+      "subjective mix quality",
+      "that the approval surrogate is a real listener preference",
+      "all possible mix edits"
+    ]
+  }
+};
+
 // packs/neon-step-sequencer/profiles/ratchet-loop-mix-level-search.json
 var ratchet_loop_mix_level_search_default = {
   version: "riddle-proof.profile.v1",
@@ -2226,7 +2410,8 @@ var rawProfiles = {
   "neon-step-sequencer-mobile-trainer-layout": mobile_trainer_layout_default,
   "neon-step-sequencer-full-mix-health-matrix": full_mix_health_matrix_default,
   "neon-step-sequencer-explore-songs-and-mixes": explore_songs_and_mixes_default,
-  "neon-step-sequencer-ratchet-loop-mix-level-search": ratchet_loop_mix_level_search_default
+  "neon-step-sequencer-ratchet-loop-mix-level-search": ratchet_loop_mix_level_search_default,
+  "neon-step-sequencer-ratchet-loop-approved-candidate": ratchet_loop_approved_candidate_default
 };
 var sourcePathOverrides = Object.freeze({
   "neon-step-sequencer-fast-mix-health": "packs/neon-step-sequencer/profiles/fast-mix-health.json",
@@ -2236,7 +2421,8 @@ var sourcePathOverrides = Object.freeze({
   "neon-step-sequencer-mobile-trainer-layout": "packs/neon-step-sequencer/profiles/mobile-trainer-layout.json",
   "neon-step-sequencer-full-mix-health-matrix": "packs/neon-step-sequencer/profiles/full-mix-health-matrix.json",
   "neon-step-sequencer-explore-songs-and-mixes": "packs/neon-step-sequencer/profiles/explore-songs-and-mixes.json",
-  "neon-step-sequencer-ratchet-loop-mix-level-search": "packs/neon-step-sequencer/profiles/ratchet-loop-mix-level-search.json"
+  "neon-step-sequencer-ratchet-loop-mix-level-search": "packs/neon-step-sequencer/profiles/ratchet-loop-mix-level-search.json",
+  "neon-step-sequencer-ratchet-loop-approved-candidate": "packs/neon-step-sequencer/profiles/ratchet-loop-approved-candidate.json"
 });
 var RIDDLE_PROOF_PACK_PROFILES = Object.freeze(
   Object.fromEntries(
@@ -2320,8 +2506,11 @@ function instantiateRiddleProofProfile(profileName, options = {}) {
 export {
   RIDDLE_PROOF_PACK_MANIFEST,
   RIDDLE_PROOF_PACK_PROFILES,
+  createDurableCandidatePatchPlan,
+  createDurableCandidatePatchPlanArtifacts,
   createHumanReviewPacketArtifacts,
   findHumanReviewPacket,
+  formatDurableCandidatePatchPlanMarkdown,
   formatHumanReviewPacketMarkdown,
   getPackEnabledRiddleProofPackProfiles,
   getRiddleProofPackProfile,

package/dist/reviewPacketCli.cjs

@@ -103,6 +103,7 @@ function formatHumanReviewPacketMarkdown(packet, options = {}) {
   const guardrails = asRecord(packet.guardrails) ?? {};
   const ranking = asRecord(packet.ranking) ?? {};
   const request = asRecord(packet.request) ?? {};
+  const approval = asRecord(request.approval) ?? {};
   const supportedCandidates = asArray(packet.supportedCandidates);
   const rejectedCandidates = asArray(packet.rejectedCandidates);
   const selectedSong = getPath(packet, "target.selectedSong.selectedSong") ?? getPath(packet, "target.routeState.selectedSong");
@@ -129,6 +130,9 @@ function formatHumanReviewPacketMarkdown(packet, options = {}) {
     `- state_restored_after_loop: ${formatCodeValue(guardrails.stateRestoredAfterLoop)}`,
     `- candidate_actions_are_transient: ${formatCodeValue(request.candidateActionsAreTransient)}`,
     `- no_permanent_edit_unless_apply_best: ${formatCodeValue(guardrails.noPermanentEditUnlessApplyBest)}`,
+    `- approved_candidate_applied: ${formatCodeValue(guardrails.approvedCandidateApplied)}`,
+    `- approval_mode: ${formatCodeValue(approval.mode)}`,
+    `- approval_basis: ${formatValue(approval.basis)}`,
     "",
     "## Ranking",
     "",

package/dist/reviewPacketCli.js

@@ -1,6 +1,6 @@
 import {
   createHumanReviewPacketArtifacts
-} from "./chunk-XQ2N4EYF.js";
+} from "./chunk-SAE6HFAG.js";
 
 // src/reviewPacketCli.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof-packs",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Reusable proof pack profiles and metadata helpers for the Riddle proof framework.",
   "license": "MIT",
   "author": "RiddleDC",
@@ -28,6 +28,7 @@
     "README.md"
   ],
   "bin": {
+    "riddle-proof-durable-candidate-plan": "./bin/riddle-proof-durable-candidate-plan",
     "riddle-proof-review-packet": "./bin/riddle-proof-review-packet"
   },
   "sideEffects": false,
@@ -43,7 +44,7 @@
     "typescript": "^5.4.5"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/reviewPacketCli.ts --format cjs,esm --dts --out-dir dist --clean",
+    "build": "tsup src/index.ts src/reviewPacketCli.ts src/durableCandidatePlanCli.ts --format cjs,esm --dts --out-dir dist --clean",
     "clean": "rm -rf dist",
     "lint": "echo 'lint: (not configured)'",
     "test": "npm run build && node test.js"

package/packs/audio-mix/ratchet-method.md

@@ -10,6 +10,18 @@ The audio ratchet is:
 6. Rerun with a sharper claim.
 7. Extract reusable pack guidance.
 
+For creative edits, add an explicit handoff gate before any durable source/config change:
+
+1. Generate bounded candidates.
+2. Keep ranking as review order only.
+3. Emit a human-review packet.
+4. Apply a candidate only when approval is explicit.
+5. Generate a durable candidate patch plan from the applied packet.
+6. Make the scoped source/config edit.
+7. Rerun a `current_target` proof that verifies the app sees the durable state.
+
+This proves the change claim and the durable application path. It still does not prove subjective mix quality.
+
 ## Smallest layer order
 
 Prefer changes in this order:

package/packs/neon-step-sequencer/README.md

@@ -28,6 +28,7 @@ This pack is the first app-specific lab for the open Riddle Proof architecture.
 - `profiles/full-mix-health-matrix.json`: current-target matrix across desktop, phone, iPad Mini, and iPad.
 - `profiles/explore-songs-and-mixes.json`: exploration sweep for proof-window health.
 - `profiles/ratchet-loop-mix-level-search.json`: bounded ratchet loop using the Neon `mix-level-search` strategy.
+- `profiles/ratchet-loop-approved-candidate.json`: bounded ratchet loop that uses an explicit operator-approval surrogate, applies the supported candidate, and keeps the listening-review caveat visible.
 
 ## Ratchet loop strategy
 
@@ -35,6 +36,10 @@ The loop is not mix-specific as a proof concept. The proof concept is a bounded
 
 This pack's first concrete strategy is `mix-level-search`, which turns small level edits into change-claim candidates. Each candidate says what action will be attempted, what receipts must support the claim, and what evidence should be reviewed afterward. The loop may include a ranking metric to order review, but the verdict comes from receipts and invariants, not from a universal mix-quality number. It still does not decide subjective mix taste; the output is a `humanReviewPacket` for listening handoff.
 
+The approved-candidate profile is the next handoff pattern after review-packet generation. It only applies a candidate when the app contract reports that the candidate's objective receipts passed, and the packet records `approvedCandidateApplied` plus the approval mode. The approval mode can keep development moving, but it is still an operator surrogate; it does not prove listener preference.
+
+The durable patch handoff is a separate step after the approved-candidate proof. A follow-on agent can validate the applied `humanReviewPacket`, generate a scoped durable candidate plan, edit the app/config source, and then run a final `current_target` proof. That handoff proves the approved candidate became visible durable state in the running app. It still does not prove the mix is aesthetically better.
+
 ## Example evidence
 
 The `examples/` directory contains local Playwright proof results captured against LilArcade Neon Step Sequencer on May 24, 2026:
@@ -45,6 +50,8 @@ The `examples/` directory contains local Playwright proof results captured again
 - `run-004-ratchet-loop-mix-level-search`: passing `interaction_snapshots` proof where a bounded loop tested six mix-level change-claim candidates, found a supported `chord -0.10` candidate, recorded receipt-level verdicts, and restored app state without keeping the edit.
 - `run-005-explore-songs-and-mixes-final`: passing `current_target` exploration sweep across four songs and eight song/part entries, with `8` passing entries, `0` prioritized findings, and no clipping after the local app-contract and mix-headroom ratchet.
 - `run-006-ratchet-loop-human-review-packet`: passing `interaction_snapshots` proof where the same bounded loop returned a compact `humanReviewPacket` with the recommended `chord -0.10` candidate, objective guardrails, `review_order_only` ranking, state restoration, and explicit listening caveats.
+- `run-007-approved-candidate-applied`: passing `interaction_snapshots` proof where an explicit `mixing_canon_surrogate` approval mode applied the supported `chord -0.10` candidate for listening review and recorded `approvedCandidateApplied`.
+- `run-008-durable-mix-patch-handoff`: passing durable handoff example where the applied packet became a scoped source/config plan for `chord: 0.28`, followed by a `current_target` proof showing the running app saw the durable level without clipping or low-level windows.
 
 ## Naming note
 

package/packs/neon-step-sequencer/case-study/findings.md

@@ -123,6 +123,28 @@ Pack summary guidance first; Riddle Proof core only if a general display primiti
 - rerun: passed on May 24, 2026 with local Playwright.
 - next sharper question: can the packet become the standard output shape for one-off and background candidate operators across more than `mix-level-search`?
 
+### Run 007 made applying a candidate explicit and auditable
+
+- run: `run-007-approved-candidate-applied`
+- claim: a bounded ratchet loop can apply a supported candidate only after an explicit approval mode, then record that final apply step without claiming subjective mix quality.
+- observed evidence: loop status was `claim_candidate_supported`; packet status was `candidate_applied_for_listening_review`; approval mode was `mixing_canon_surrogate`; recommended candidate was `chord -0.10`; applied-candidate receipt passed with observed level `0.28`; supported candidate count was `6`; rejected candidate count was `0`; state was restored before the final apply; ranking role stayed `review_order_only`.
+- classification: none; passing `interaction_snapshots` proof with subjective listening caveat.
+- smallest layer changed: app proof contract and proof-pack profile assertions.
+- change made: made `applyBest` require a supported claim candidate, added an applied-candidate receipt, surfaced approval metadata in the human-review packet, and added an approved-candidate profile.
+- rerun: passed on May 24, 2026 with local Playwright.
+- next sharper question: can follow-on agents use the applied-candidate packet to prepare a code/config patch only when the operator explicitly asks for a durable edit?
+
+### Run 008 closed the durable source handoff
+
+- run: `run-008-durable-mix-patch-handoff`
+- claim: an applied human-review packet can become a scoped source/config patch only after durable-readiness validation, and the running app should then prove it sees that durable state.
+- observed evidence: durable plan status was `ready_for_durable_patch`; source file was `src/Games/songs/neon-approved-mix-overrides.json`; target was `Monkberry Moon Delight (Tab)` with mix profile `monkberry-moon-delight-eq-lane-mix-v7`; durable mixer level was `chord: 0.28`; final current-target proof passed with contract chord level `0.28`, peak `0.8303`, RMS `0.1234`, clipping `false`, low-level window `false`, and `6` active instruments.
+- classification: none; passing durable handoff plus `current_target` proof with subjective listening caveat.
+- smallest layer changed: reusable pack helper/CLI, app source override, and proof-pack example docs.
+- change made: added a durable candidate plan helper that refuses transient/unapproved packets, committed a scoped Neon override in the app, and captured final proof that the running app saw the durable level.
+- rerun: passed on May 24, 2026 with local Playwright and deployed in LilArcade PR #490.
+- next sharper question: can this durable handoff become the default follow-on step for proof-backed creative edits across more strategies than `mix-level-search`?
+
 ### Local runner shutdown needs a small ergonomics follow-up
 
 - run: `run-002-mix-change`, `run-003-full-matrix`, `run-004-ratchet-loop-mix-level-search`

package/packs/neon-step-sequencer/case-study/ratchet-card.md

@@ -36,7 +36,9 @@ The project shows that a complex audio app can improve proof confidence mostly b
 - Run 004: a bounded loop tested six `mix-level-search` change-claim candidates, returned `chord -0.10` as a supported review candidate with receipt-level evidence, and restored app state.
 - Run 005: a `current_target` exploration sweep sampled four songs and eight song/part entries. The first real sweep exposed app-contract normalization gaps and hot built-in song presets; after the local ratchet fixes it passed with `8` entries, `0` findings, and no clipping.
 - Run 006: the bounded loop returned a compact `humanReviewPacket` with the supported `chord -0.10` candidate, objective guardrails, state restoration, review-order ranking, and listening caveats.
+- Run 007: the approved-candidate profile used a `mixing_canon_surrogate` approval mode, restored loop state, applied the supported `chord -0.10` candidate, and recorded an applied-candidate receipt for listening review.
+- Run 008: the applied packet became a durable candidate patch plan for `chord: 0.28`, the app stored it as a scoped source override, and a final `current_target` proof verified the running app saw the durable level without clipping or low-level windows.
 
 ## Honest boundary
 
-These runs prove objective claims about a running app target. They do not prove that the mix is tasteful, that every song section is healthy, or that a release candidate is better than production. Run 005 is still bounded to configured song/part limits. Run 006 makes the human handoff explicit: the packet is a compact review object, not an automated taste verdict. The ratchet loop is a generic proof-loop shape; `mix-level-search` is only the first Neon strategy plugged into it.
+These runs prove objective claims about a running app target. They do not prove that the mix is tasteful, that every song section is healthy, or that a release candidate is better than production. Run 005 is still bounded to configured song/part limits. Runs 006 and 007 make the human handoff explicit: the packet is a compact review object, and the approval mode is a visible operator/surrogate choice, not an automated taste verdict. Run 008 proves durable application and current-target visibility, not listener preference. The ratchet loop is a generic proof-loop shape; `mix-level-search` is only the first Neon strategy plugged into it.

package/packs/neon-step-sequencer/case-study/ratchet-log.md

@@ -337,6 +337,118 @@ Next sharper question:
 
 Can one-off commands and background runs use this packet as their common output surface while strategy-specific code remains behind the app contract?
 
+## Run 007 - Approved candidate applied
+
+Claim:
+
+Neon can use an explicit approval mode to apply a supported change-claim candidate for listening review while keeping objective proof receipts and subjective taste separate.
+
+Profile:
+
+`profiles/ratchet-loop-approved-candidate.json`
+
+Evidence to capture:
+
+- supported claim candidate
+- explicit approval mode
+- state restoration before the final apply
+- applied-candidate receipt
+- compact human-review packet
+- listening-review caveat
+
+Possible outcomes:
+
+- `candidate_applied_for_listening_review`: a supported candidate was applied after explicit approval and the final app state reflects the candidate.
+- `candidate_ready_for_listening_review`: a supported candidate exists, but the profile did not request final application.
+- `needs_human_review`: no candidate satisfied every objective receipt.
+- `product_regression`: the selected candidate could not be applied or the final mixer state did not reflect it.
+
+Observed status:
+
+Passed on May 24, 2026 with `local-playwright`.
+
+Observed evidence:
+
+- loop status `claim_candidate_supported`
+- packet status `candidate_applied_for_listening_review`
+- approval mode `mixing_canon_surrogate`
+- recommended candidate `chord -0.10`
+- final applied level `0.28`
+- applied-candidate receipt `ok`
+- supported candidates `6`
+- rejected candidates `0`
+- state restored before apply `true`
+- ranking role `review_order_only`
+
+Failure classification:
+
+None. This was a passing `interaction_snapshots` proof. The approval mode is intentionally labeled as a surrogate so the packet does not imply a real listener has judged the mix.
+
+Smallest layer changed:
+
+App proof contract and proof-pack profile. Riddle Proof core did not need a change.
+
+Next sharper question:
+
+Can the reusable pack expose this approved-candidate shape without making approval automatic, and can follow-on agents use the packet to prepare a code/config patch only when the operator explicitly asks for one?
+
+## Run 008 - Durable mix patch handoff
+
+Claim:
+
+An explicitly applied human-review packet can become a scoped durable source/config patch, and a final current-target proof can verify the running app sees that durable state without claiming subjective mix quality.
+
+Profile:
+
+`profiles/fast-mix-health.json`
+
+Evidence to capture:
+
+- applied human-review packet
+- durable candidate patch plan
+- source/config target
+- current app contract mixer state
+- offline mix-health metrics
+- listening-review caveat
+
+Possible outcomes:
+
+- `ready_for_durable_patch`: the packet is applied, approved, non-transient, ranked for review only, and still preserves the listening-review caveat.
+- `not_ready_for_durable_patch`: the packet is still transient, lacks approval metadata, has a disallowed action, lacks required target scope, or dropped the proof/taste boundary.
+- `current_target_passed`: the durable source edit is visible to the running app and current audio guardrails pass.
+- `product_regression`: the durable edit is not reflected in app state or the current target clips / falls below level guardrails.
+
+Observed status:
+
+Passed on May 24, 2026 with `local-playwright`.
+
+Observed evidence:
+
+- durable plan status `ready_for_durable_patch`
+- source file `src/Games/songs/neon-approved-mix-overrides.json`
+- target `Monkberry Moon Delight (Tab)`
+- mix profile `monkberry-moon-delight-eq-lane-mix-v7`
+- durable mixer level `chord: 0.28`
+- current-target profile status `passed`
+- contract chord level `0.28`
+- peak `0.8303`
+- RMS `0.1234`
+- clipping `false`
+- low-level window `false`
+- active instruments `6`
+
+Failure classification:
+
+None. This was a passing durable handoff plus `current_target` proof. It proves scoped durable application and browser-visible state, not listener preference.
+
+Smallest layer changed:
+
+Reusable proof-pack helper/CLI, app source override, and proof-pack example docs. Riddle Proof core did not need a change.
+
+Next sharper question:
+
+Can this durable handoff become the default follow-on step after approved packets for more creative strategies than `mix-level-search`?
+
 ## Project note
 
 The ratchet is not a pass. The ratchet is the next sharper question.

package/packs/neon-step-sequencer/examples/README.md

@@ -2,7 +2,7 @@
 
 These examples are local Playwright runner outputs captured against LilArcade Neon Step Sequencer on May 24, 2026. They are included to show how this pack records atomic proof claims with explicit evidence-role patterns.
 
-The raw `profile-result.json` files are real runner outputs. They intentionally keep enough evidence to audit the verdict, but the summaries are the preferred place to start. Run 006 also includes standalone `human-review-packet.json` and `human-review-packet.md` files generated from the proof artifact.
+The raw `profile-result.json` files are real runner outputs. They intentionally keep enough evidence to audit the verdict, but the summaries are the preferred place to start. Runs 006, 007, and 008 also include standalone handoff artifacts generated from proof output.
 
 ## Runs
 
@@ -14,6 +14,8 @@ The raw `profile-result.json` files are real runner outputs. They intentionally
 | `run-004-ratchet-loop-mix-level-search` | `interaction_snapshots` | passed | A bounded ratchet loop tests mix-level change-claim candidates, records receipt verdicts, chooses a supported candidate for review, and restores app state. |
 | `run-005-explore-songs-and-mixes-final` | `current_target` | passed | A bounded exploration sweep samples four songs and eight song/part entries, producing a zero-finding confidence map after app-contract and mix-headroom fixes. |
 | `run-006-ratchet-loop-human-review-packet` | `interaction_snapshots` | passed | A bounded ratchet loop returns a compact `humanReviewPacket` for handoff: supported candidates, objective guardrails, state restoration, review-order ranking, and listening caveats. |
+| `run-007-approved-candidate-applied` | `interaction_snapshots` | passed | A bounded ratchet loop uses an explicit operator-approval surrogate, applies the supported `chord -0.10` candidate, and keeps the listening-review caveat in the packet. |
+| `run-008-durable-mix-patch-handoff` | `current_target` | passed | An applied packet becomes a durable candidate patch plan for `chord: 0.28`, then a current-target proof verifies the running app sees that durable level without clipping. |
 
 ## What these examples do not prove
 
@@ -24,3 +26,5 @@ The raw `profile-result.json` files are real runner outputs. They intentionally
 - The ratchet-loop run does not prove that the loop primitive is mix-specific; `mix-level-search` is only this pack's first concrete strategy.
 - The ratchet-loop run does not prove that the supported candidate should be kept. Its ranking metric is a review-order hint, not a taste verdict.
 - The human-review packet does not replace listening judgment. It compresses objective receipts and caveats so a person or follow-on agent can decide what to review next.
+- The approved-candidate run does not prove that the surrogate approval is a real listener preference; it proves that the apply step was explicit, guarded by supported receipts, and recorded for review.
+- The durable handoff run does not prove the mix is better. It proves the approved candidate was eligible for scoped source/config application and that the app saw the durable result afterward.

package/packs/neon-step-sequencer/examples/run-006-ratchet-loop-human-review-packet/human-review-packet.md

@@ -20,6 +20,9 @@
 - state_restored_after_loop: `true`
 - candidate_actions_are_transient: `true`
 - no_permanent_edit_unless_apply_best: `true`
+- approved_candidate_applied: `not captured`
+- approval_mode: `not captured`
+- approval_basis: not captured
 
 ## Ranking
 

package/packs/neon-step-sequencer/examples/run-007-approved-candidate-applied/artifact-manifest.json

@@ -0,0 +1,32 @@
+{
+  "version": "riddle-proof-local-runner-manifest.v1",
+  "runner": "local-playwright",
+  "profile_name": "lilarcade-neon-ratchet-loop-approved-candidate",
+  "captured_at": "2026-05-24T13:41:23.987Z",
+  "artifacts": [
+    {
+      "name": "proof.json",
+      "path": "proof.json",
+      "kind": "text",
+      "bytes": 506212
+    },
+    {
+      "name": "console.json",
+      "path": "console.json",
+      "kind": "text",
+      "bytes": 38
+    },
+    {
+      "name": "dom-summary.json",
+      "path": "dom-summary.json",
+      "kind": "text",
+      "bytes": 815
+    },
+    {
+      "name": "profile-result.json",
+      "path": "profile-result.json",
+      "kind": "text",
+      "bytes": 506212
+    }
+  ]
+}

package/packs/neon-step-sequencer/examples/run-007-approved-candidate-applied/console.json

@@ -0,0 +1,4 @@
+{
+  "events": [],
+  "fatal_count": 0
+}

package/packs/neon-step-sequencer/examples/run-007-approved-candidate-applied/dom-summary.json

@@ -0,0 +1,40 @@
+{
+  "expected_viewport_count": 1,
+  "viewport_count": 1,
+  "partial": false,
+  "routes": [
+    {
+      "requested": "http://127.0.0.1:5177/games/drum-sequencer?song=monkberry-moon-delight-tab&mix=profile&view=trainer&instrument=bass",
+      "observed": "/games/drum-sequencer",
+      "expected_path": "/games/drum-sequencer",
+      "matched": true,
+      "http_status": 200
+    }
+  ],
+  "titles": [
+    "LilArcade"
+  ],
+  "overflow_px": [
+    0
+  ],
+  "bounds_overflow_px": [
+    0
+  ],
+  "overflow_offender_counts": [
+    0
+  ],
+  "frames": [
+    {
+      "viewport": "desktop",
+      "selectors": []
+    }
+  ],
+  "http_status": [],
+  "link_status": [],
+  "route_inventory": [],
+  "network_mock_count": 0,
+  "network_mock_hit_count": 0,
+  "dialog_count": 0,
+  "dialog_accept_count": 0,
+  "dialog_dismiss_count": 0
+}