@riddledc/riddle-proof-packs 0.4.6 → 0.4.8

package/dist/index.cjs

@@ -22,8 +22,11 @@ var index_exports = {};
 __export(index_exports, {
   RIDDLE_PROOF_PACK_MANIFEST: () => RIDDLE_PROOF_PACK_MANIFEST,
   RIDDLE_PROOF_PACK_PROFILES: () => RIDDLE_PROOF_PACK_PROFILES,
+  createDurableCandidatePatchPlan: () => createDurableCandidatePatchPlan,
+  createDurableCandidatePatchPlanArtifacts: () => createDurableCandidatePatchPlanArtifacts,
   createHumanReviewPacketArtifacts: () => createHumanReviewPacketArtifacts,
   findHumanReviewPacket: () => findHumanReviewPacket,
+  formatDurableCandidatePatchPlanMarkdown: () => formatDurableCandidatePatchPlanMarkdown,
   formatHumanReviewPacketMarkdown: () => formatHumanReviewPacketMarkdown,
   getPackEnabledRiddleProofPackProfiles: () => getPackEnabledRiddleProofPackProfiles,
   getRiddleProofPackProfile: () => getRiddleProofPackProfile,
@@ -1549,16 +1552,16 @@ var playback_sync_default = {
         label: "capture-pre-playback-state",
         timeout_ms: 1e4,
         store_return_to: "__neonProof.prePlayback",
-        script: "const api=window.__NEON_MIX_PROOF__||window.__RIDDLE_SEQUENCER_PROOF__; const state=api?.getPlaybackState?.()||api?.getSummary?.()?.trainer||null; window.__neonProof={...(window.__neonProof||{}),prePlayback:{available:Boolean(api),state}}; return window.__neonProof.prePlayback;",
+        script: "const api=window.__NEON_MIX_PROOF__||window.__RIDDLE_SEQUENCER_PROOF__; const raw=api?.getPlaybackState?.()||api?.getSummary?.()||null; const trainer=raw?.trainer||raw||{}; const out={available:Boolean(api),isPlaying:Boolean(raw?.isPlaying),currentStep:Number(trainer.currentStep??-1),selectedInstrument:trainer.selectedInstrument||null,state:raw}; window.__neonProof={...(window.__neonProof||{}),prePlayback:out}; return out;",
         return_summary_fields: [
           {
             path: "available"
           },
           {
-            path: "state.selectedInstrument"
+            path: "selectedInstrument"
           },
           {
-            path: "state.currentStep"
+            path: "currentStep"
           }
         ]
       },
@@ -1573,6 +1576,12 @@ var playback_sync_default = {
         selector: "button.drum-play",
         timeout_ms: 1e4
       },
+      {
+        type: "wait_for_text",
+        selector: "button.drum-play",
+        text: "Stop",
+        timeout_ms: 3e4
+      },
       {
         type: "wait",
         ms: 900
@@ -1582,16 +1591,19 @@ var playback_sync_default = {
         label: "capture-post-playback-state",
         timeout_ms: 1e4,
         store_return_to: "__neonProof.postPlayback",
-        script: "const api=window.__NEON_MIX_PROOF__||window.__RIDDLE_SEQUENCER_PROOF__; const state=api?.getPlaybackState?.()||api?.getSummary?.()?.trainer||null; const summary=api?.getState?.()||api?.getSummary?.()||{}; const out={available:Boolean(api),isPlaying:Boolean(summary.isPlaying),state}; window.__neonProof={...(window.__neonProof||{}),postPlayback:out}; return out;",
+        script: "const api=window.__NEON_MIX_PROOF__||window.__RIDDLE_SEQUENCER_PROOF__; const raw=api?.getPlaybackState?.()||api?.getSummary?.()||null; const trainer=raw?.trainer||raw||{}; const pre=window.__neonProof?.prePlayback||{}; const currentStep=Number(trainer.currentStep??-1); const preStep=Number(pre.currentStep??-1); const out={available:Boolean(api),isPlaying:Boolean(raw?.isPlaying),currentStep,preStep,selectedInstrument:trainer.selectedInstrument||null,movedForward:currentStep>preStep,state:raw}; window.__neonProof={...(window.__neonProof||{}),postPlayback:out}; return out;",
         return_summary_fields: [
           {
             path: "isPlaying"
           },
           {
-            path: "state.currentStep"
+            path: "currentStep"
+          },
+          {
+            path: "selectedInstrument"
           },
           {
-            path: "state.selectedInstrument"
+            path: "movedForward"
           }
         ]
       },
@@ -1601,6 +1613,18 @@ var playback_sync_default = {
         expected_value: true,
         timeout_ms: 1e4
       },
+      {
+        type: "assert_window_value",
+        path: "__neonProof.postPlayback.isPlaying",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonProof.postPlayback.movedForward",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
       {
         type: "screenshot",
         label: "neon-playback-sync",
@@ -1645,7 +1669,9 @@ var playback_sync_default = {
     required_receipts: [
       "pre-action playback state",
       "play button interaction",
-      "post-action playback state",
+      "visible Stop state after interaction",
+      "post-action playback state is playing",
+      "post-action trainer step moved forward",
       "screenshot after interaction"
     ],
     does_not_prove: [
@@ -2663,12 +2689,225 @@ function createHumanReviewPacketArtifacts(proofOrPacket, options = {}) {
     markdown
   };
 }
+
+// src/durableCandidatePlan.ts
+var DEFAULT_APPROVAL_MODES = ["operator_approved", "mixing_canon_surrogate"];
+var DEFAULT_ACTION_TYPES = ["set_mixer_level"];
+var isRecord3 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var asRecord2 = (value) => isRecord3(value) ? value : {};
+var getPath2 = (value, path) => {
+  let cursor = value;
+  for (const part of path.split(".")) {
+    if (!isRecord3(cursor)) return void 0;
+    cursor = cursor[part];
+  }
+  return cursor;
+};
+var asFiniteNumber = (value) => {
+  if (value === null || value === void 0 || value === "") return null;
+  if (typeof value !== "number" && typeof value !== "string") return null;
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? Number(numeric.toFixed(4)) : null;
+};
+var formatValue2 = (value) => {
+  if (value === null || value === void 0 || value === "") return "not captured";
+  if (typeof value === "number") return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(4)));
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return String(value);
+};
+var formatCodeValue2 = (value) => `\`${formatValue2(value)}\``;
+var selectedTargetLabel = (packet) => {
+  const value = getPath2(packet, "target.selectedSong.selectedSong") ?? getPath2(packet, "target.routeState.selectedSong") ?? getPath2(packet, "target.label");
+  return typeof value === "string" && value.trim() ? value : null;
+};
+var selectedRoute = (packet) => {
+  const value = getPath2(packet, "target.routeState.route") ?? getPath2(packet, "target.routeState.path") ?? getPath2(packet, "target.route");
+  return typeof value === "string" && value.trim() ? value : null;
+};
+var selectedMixProfileId = (packet) => {
+  const value = getPath2(packet, "recommendation.candidate.summary.mixProfile.id") ?? getPath2(packet, "baseline.mixProfile.id") ?? getPath2(packet, "target.mixProfile.id");
+  return typeof value === "string" && value.trim() ? value : null;
+};
+function createDurableCandidatePatchPlan(proofOrPacket, options = {}) {
+  const packet = requireHumanReviewPacket(proofOrPacket);
+  const recommendation = asRecord2(packet.recommendation);
+  const candidate = asRecord2(recommendation.candidate);
+  const action = asRecord2(candidate.action);
+  const guardrails = asRecord2(packet.guardrails);
+  const request = asRecord2(packet.request);
+  const approval = asRecord2(request.approval);
+  const ranking = asRecord2(packet.ranking);
+  const proofBoundary = packet.proofBoundary;
+  const target = {
+    label: selectedTargetLabel(packet),
+    route: selectedRoute(packet),
+    mixProfileId: selectedMixProfileId(packet)
+  };
+  const actionType = action.type;
+  const actionTrack = action.track;
+  const from = asFiniteNumber(action.from);
+  const to = asFiniteNumber(action.to);
+  const numericDelta = asFiniteNumber(action.delta);
+  const delta = numericDelta ?? (from !== null && to !== null ? asFiniteNumber(to - from) : null);
+  const allowedApprovalModes = new Set(options.allowedApprovalModes ?? DEFAULT_APPROVAL_MODES);
+  const allowedActionTypes = new Set(options.allowedActionTypes ?? DEFAULT_ACTION_TYPES);
+  const errors = [];
+  if (packet.status !== "candidate_applied_for_listening_review") {
+    errors.push("packet status must be candidate_applied_for_listening_review");
+  }
+  if (recommendation.action !== "listen_to_applied_candidate") {
+    errors.push("recommendation action must be listen_to_applied_candidate");
+  }
+  if (guardrails.approvedCandidateApplied !== true) {
+    errors.push("approvedCandidateApplied guardrail must be true");
+  }
+  if (request.candidateActionsAreTransient !== false) {
+    errors.push("candidateActionsAreTransient must be false before a durable patch handoff");
+  }
+  if (!approval.mode) {
+    errors.push("approval mode is required");
+  } else if (!allowedApprovalModes.has(String(approval.mode))) {
+    errors.push(`approval mode ${formatValue2(approval.mode)} is not allowed for durable patch handoff`);
+  }
+  if (ranking.role !== "review_order_only") {
+    errors.push("ranking role must remain review_order_only");
+  }
+  if (!String(proofBoundary ?? "").includes("musical taste still requires listening review")) {
+    errors.push("proof boundary must preserve the listening-review caveat");
+  }
+  if (!actionType || !allowedActionTypes.has(String(actionType))) {
+    errors.push(`action type ${formatValue2(actionType)} is not allowed for durable patch handoff`);
+  }
+  if (typeof actionTrack !== "string" || !actionTrack.trim()) {
+    errors.push("candidate action track is required");
+  }
+  if (to === null) {
+    errors.push("candidate action target value is required");
+  }
+  if (String(actionType) === "set_mixer_level" && (to === null || to < 0 || to > 1.5)) {
+    errors.push("set_mixer_level target must be between 0 and 1.5");
+  }
+  if (options.requireTargetLabel !== false && !target.label) {
+    errors.push("target label is required for a scoped durable patch handoff");
+  }
+  if (options.requireMixProfileId === true && !target.mixProfileId) {
+    errors.push("mixProfileId is required for this durable patch handoff");
+  }
+  const actionShape = {
+    type: actionType ?? null,
+    track: actionTrack ?? null,
+    from,
+    to,
+    delta
+  };
+  const mixerLevels = !errors.length && String(actionType) === "set_mixer_level" && typeof actionTrack === "string" && to !== null ? { [actionTrack]: to } : null;
+  return {
+    version: "riddle-proof.durable-candidate-patch-plan.v1",
+    kind: "durable_candidate_patch_plan",
+    status: errors.length ? "not_ready_for_durable_patch" : "ready_for_durable_patch",
+    ok: errors.length === 0,
+    errors,
+    source: {
+      packetStatus: packet.status ?? null,
+      recommendationAction: recommendation.action ?? null,
+      rankingRole: ranking.role ?? null,
+      proofBoundary: proofBoundary ?? null
+    },
+    target,
+    candidate: {
+      label: candidate.label ?? null,
+      action: actionShape
+    },
+    approval: {
+      mode: approval.mode ?? null,
+      approvedBy: approval.approvedBy ?? null,
+      basis: approval.basis ?? null
+    },
+    durableEdit: errors.length ? null : {
+      sourceFile: options.sourceFile ?? null,
+      target,
+      action: actionShape,
+      mixerLevels,
+      provenance: {
+        humanReviewPacketStatus: packet.status ?? null,
+        recommendationLabel: candidate.label ?? null,
+        approvalMode: approval.mode ?? null,
+        approvedBy: approval.approvedBy ?? null,
+        basis: approval.basis ?? null
+      },
+      doesNotProve: [
+        "subjective mix quality",
+        "that the approval surrogate is a real listener preference",
+        "all possible candidate edits"
+      ]
+    },
+    boundary: "This is a durable patch handoff for an approved listening-review candidate. It does not prove subjective mix quality.",
+    caveats: [
+      "A durable patch plan is not a taste verdict.",
+      "Ranking orders review only; it is not a universal mix-quality score.",
+      "Run a final current-target proof after the durable edit lands."
+    ]
+  };
+}
+function formatDurableCandidatePatchPlanMarkdown(plan, options = {}) {
+  if (plan.kind !== "durable_candidate_patch_plan") {
+    throw new Error("Expected a durable_candidate_patch_plan");
+  }
+  const lines = [
+    `# ${options.title ?? "Durable Candidate Patch Plan"}`,
+    "",
+    `- status: ${formatCodeValue2(plan.status)}`,
+    `- ok: ${formatCodeValue2(plan.ok)}`,
+    `- target_label: ${formatValue2(plan.target.label)}`,
+    `- mix_profile_id: ${formatCodeValue2(plan.target.mixProfileId)}`,
+    `- source_file: ${formatCodeValue2(plan.durableEdit?.sourceFile)}`,
+    "",
+    "## Candidate",
+    "",
+    `- label: ${formatCodeValue2(plan.candidate.label)}`,
+    `- action: ${formatCodeValue2(`${formatValue2(plan.candidate.action.type)} ${formatValue2(plan.candidate.action.track)}: ${formatValue2(plan.candidate.action.from)} -> ${formatValue2(plan.candidate.action.to)} (${formatValue2(plan.candidate.action.delta)})`)}`,
+    "",
+    "## Approval Boundary",
+    "",
+    `- approval_mode: ${formatCodeValue2(plan.approval.mode)}`,
+    `- approved_by: ${formatCodeValue2(plan.approval.approvedBy)}`,
+    `- basis: ${formatValue2(plan.approval.basis)}`,
+    `- boundary: ${formatValue2(plan.boundary)}`,
+    "",
+    "## Durable Edit",
+    "",
+    `- mixer_levels: ${formatCodeValue2(JSON.stringify(plan.durableEdit?.mixerLevels ?? null))}`
+  ];
+  if (plan.errors.length) {
+    lines.push("", "## Errors", "");
+    for (const error of plan.errors) lines.push(`- ${error}`);
+  }
+  lines.push("", "## Caveats", "");
+  for (const caveat of plan.caveats) lines.push(`- ${caveat}`);
+  return `${lines.join("\n")}
+`;
+}
+function createDurableCandidatePatchPlanArtifacts(proofOrPacket, options = {}) {
+  const plan = createDurableCandidatePatchPlan(proofOrPacket, options);
+  const markdown = formatDurableCandidatePatchPlanMarkdown(plan, {
+    title: options.title
+  });
+  return {
+    plan,
+    json: `${JSON.stringify(plan, null, 2)}
+`,
+    markdown
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RIDDLE_PROOF_PACK_MANIFEST,
   RIDDLE_PROOF_PACK_PROFILES,
+  createDurableCandidatePatchPlan,
+  createDurableCandidatePatchPlanArtifacts,
   createHumanReviewPacketArtifacts,
   findHumanReviewPacket,
+  formatDurableCandidatePatchPlanMarkdown,
   formatHumanReviewPacketMarkdown,
   getPackEnabledRiddleProofPackProfiles,
   getRiddleProofPackProfile,

package/dist/index.d.cts

@@ -1,6 +1,7 @@
 import * as _riddledc_riddle_proof from '@riddledc/riddle-proof';
 import { RiddleProofProfile } from '@riddledc/riddle-proof';
 export { H as HumanReviewPacket, a as HumanReviewPacketArtifacts, b as HumanReviewPacketMarkdownOptions, c as createHumanReviewPacketArtifacts, f as findHumanReviewPacket, d as formatHumanReviewPacketMarkdown, r as requireHumanReviewPacket } from './humanReviewPacket-APSxuvat.cjs';
+export { D as DurableCandidatePatchPlan, a as DurableCandidatePatchPlanArtifacts, b as DurableCandidatePatchPlanOptions, c as createDurableCandidatePatchPlan, d as createDurableCandidatePatchPlanArtifacts, f as formatDurableCandidatePatchPlanMarkdown } from './durableCandidatePlan-Dv2P33Wg.cjs';
 
 interface RiddleProofPackProfileManifest {
     /** Profile slug and canonical manifest key. */

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as _riddledc_riddle_proof from '@riddledc/riddle-proof';
 import { RiddleProofProfile } from '@riddledc/riddle-proof';
 export { H as HumanReviewPacket, a as HumanReviewPacketArtifacts, b as HumanReviewPacketMarkdownOptions, c as createHumanReviewPacketArtifacts, f as findHumanReviewPacket, d as formatHumanReviewPacketMarkdown, r as requireHumanReviewPacket } from './humanReviewPacket-APSxuvat.js';
+export { D as DurableCandidatePatchPlan, a as DurableCandidatePatchPlanArtifacts, b as DurableCandidatePatchPlanOptions, c as createDurableCandidatePatchPlan, d as createDurableCandidatePatchPlanArtifacts, f as formatDurableCandidatePatchPlanMarkdown } from './durableCandidatePlan-Dv2P33Wg.js';
 
 interface RiddleProofPackProfileManifest {
     /** Profile slug and canonical manifest key. */

package/dist/index.js

@@ -1,3 +1,8 @@
+import {
+  createDurableCandidatePatchPlan,
+  createDurableCandidatePatchPlanArtifacts,
+  formatDurableCandidatePatchPlanMarkdown
+} from "./chunk-VFPSPQD7.js";
 import {
   createHumanReviewPacketArtifacts,
   findHumanReviewPacket,
@@ -1517,16 +1522,16 @@ var playback_sync_default = {
         label: "capture-pre-playback-state",
         timeout_ms: 1e4,
         store_return_to: "__neonProof.prePlayback",
-        script: "const api=window.__NEON_MIX_PROOF__||window.__RIDDLE_SEQUENCER_PROOF__; const state=api?.getPlaybackState?.()||api?.getSummary?.()?.trainer||null; window.__neonProof={...(window.__neonProof||{}),prePlayback:{available:Boolean(api),state}}; return window.__neonProof.prePlayback;",
+        script: "const api=window.__NEON_MIX_PROOF__||window.__RIDDLE_SEQUENCER_PROOF__; const raw=api?.getPlaybackState?.()||api?.getSummary?.()||null; const trainer=raw?.trainer||raw||{}; const out={available:Boolean(api),isPlaying:Boolean(raw?.isPlaying),currentStep:Number(trainer.currentStep??-1),selectedInstrument:trainer.selectedInstrument||null,state:raw}; window.__neonProof={...(window.__neonProof||{}),prePlayback:out}; return out;",
         return_summary_fields: [
           {
             path: "available"
           },
           {
-            path: "state.selectedInstrument"
+            path: "selectedInstrument"
           },
           {
-            path: "state.currentStep"
+            path: "currentStep"
           }
         ]
       },
@@ -1541,6 +1546,12 @@ var playback_sync_default = {
         selector: "button.drum-play",
         timeout_ms: 1e4
       },
+      {
+        type: "wait_for_text",
+        selector: "button.drum-play",
+        text: "Stop",
+        timeout_ms: 3e4
+      },
       {
         type: "wait",
         ms: 900
@@ -1550,16 +1561,19 @@ var playback_sync_default = {
         label: "capture-post-playback-state",
         timeout_ms: 1e4,
         store_return_to: "__neonProof.postPlayback",
-        script: "const api=window.__NEON_MIX_PROOF__||window.__RIDDLE_SEQUENCER_PROOF__; const state=api?.getPlaybackState?.()||api?.getSummary?.()?.trainer||null; const summary=api?.getState?.()||api?.getSummary?.()||{}; const out={available:Boolean(api),isPlaying:Boolean(summary.isPlaying),state}; window.__neonProof={...(window.__neonProof||{}),postPlayback:out}; return out;",
+        script: "const api=window.__NEON_MIX_PROOF__||window.__RIDDLE_SEQUENCER_PROOF__; const raw=api?.getPlaybackState?.()||api?.getSummary?.()||null; const trainer=raw?.trainer||raw||{}; const pre=window.__neonProof?.prePlayback||{}; const currentStep=Number(trainer.currentStep??-1); const preStep=Number(pre.currentStep??-1); const out={available:Boolean(api),isPlaying:Boolean(raw?.isPlaying),currentStep,preStep,selectedInstrument:trainer.selectedInstrument||null,movedForward:currentStep>preStep,state:raw}; window.__neonProof={...(window.__neonProof||{}),postPlayback:out}; return out;",
         return_summary_fields: [
           {
             path: "isPlaying"
           },
           {
-            path: "state.currentStep"
+            path: "currentStep"
           },
           {
-            path: "state.selectedInstrument"
+            path: "selectedInstrument"
+          },
+          {
+            path: "movedForward"
           }
         ]
       },
@@ -1569,6 +1583,18 @@ var playback_sync_default = {
         expected_value: true,
         timeout_ms: 1e4
       },
+      {
+        type: "assert_window_value",
+        path: "__neonProof.postPlayback.isPlaying",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonProof.postPlayback.movedForward",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
       {
         type: "screenshot",
         label: "neon-playback-sync",
@@ -1613,7 +1639,9 @@ var playback_sync_default = {
     required_receipts: [
       "pre-action playback state",
       "play button interaction",
-      "post-action playback state",
+      "visible Stop state after interaction",
+      "post-action playback state is playing",
+      "post-action trainer step moved forward",
       "screenshot after interaction"
     ],
     does_not_prove: [
@@ -2501,8 +2529,11 @@ function instantiateRiddleProofProfile(profileName, options = {}) {
 export {
   RIDDLE_PROOF_PACK_MANIFEST,
   RIDDLE_PROOF_PACK_PROFILES,
+  createDurableCandidatePatchPlan,
+  createDurableCandidatePatchPlanArtifacts,
   createHumanReviewPacketArtifacts,
   findHumanReviewPacket,
+  formatDurableCandidatePatchPlanMarkdown,
   formatHumanReviewPacketMarkdown,
   getPackEnabledRiddleProofPackProfiles,
   getRiddleProofPackProfile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof-packs",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "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

@@ -38,6 +38,8 @@ This pack's first concrete strategy is `mix-level-search`, which turns small lev
 
 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:
@@ -48,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

@@ -134,6 +134,17 @@ 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 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

@@ -37,7 +37,8 @@ The project shows that a complex audio app can improve proof confidence mostly b
 - 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. 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. 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

@@ -392,6 +392,63 @@ 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. Runs 006 and 007 also include 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
 
@@ -15,6 +15,7 @@ The raw `profile-result.json` files are real runner outputs. They intentionally
 | `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
 
@@ -26,3 +27,4 @@ The raw `profile-result.json` files are real runner outputs. They intentionally
 - 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.