@riddledc/riddle-proof-packs 0.4.5 → 0.4.7

package/dist/durableCandidatePlanCli.cjs

@@ -0,0 +1,445 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/durableCandidatePlanCli.ts
+var durableCandidatePlanCli_exports = {};
+__export(durableCandidatePlanCli_exports, {
+  main: () => main,
+  parseDurableCandidatePlanCliArgs: () => parseDurableCandidatePlanCliArgs,
+  writeDurableCandidatePlanFiles: () => writeDurableCandidatePlanFiles
+});
+module.exports = __toCommonJS(durableCandidatePlanCli_exports);
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"), 1);
+
+// src/humanReviewPacket.ts
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+function findHumanReviewPacket(value) {
+  if (!value || typeof value !== "object") return null;
+  if (isRecord(value) && value.kind === "human_review_packet") return value;
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const packet = findHumanReviewPacket(entry);
+      if (packet) return packet;
+    }
+    return null;
+  }
+  for (const entry of Object.values(value)) {
+    const packet = findHumanReviewPacket(entry);
+    if (packet) return packet;
+  }
+  return null;
+}
+function requireHumanReviewPacket(value) {
+  const packet = findHumanReviewPacket(value);
+  if (!packet) throw new Error("No human_review_packet found");
+  return packet;
+}
+
+// src/durableCandidatePlan.ts
+var DEFAULT_APPROVAL_MODES = ["operator_approved", "mixing_canon_surrogate"];
+var DEFAULT_ACTION_TYPES = ["set_mixer_level"];
+var isRecord2 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var asRecord = (value) => isRecord2(value) ? value : {};
+var getPath = (value, path2) => {
+  let cursor = value;
+  for (const part of path2.split(".")) {
+    if (!isRecord2(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 formatValue = (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 formatCodeValue = (value) => `\`${formatValue(value)}\``;
+var selectedTargetLabel = (packet) => {
+  const value = getPath(packet, "target.selectedSong.selectedSong") ?? getPath(packet, "target.routeState.selectedSong") ?? getPath(packet, "target.label");
+  return typeof value === "string" && value.trim() ? value : null;
+};
+var selectedRoute = (packet) => {
+  const value = getPath(packet, "target.routeState.route") ?? getPath(packet, "target.routeState.path") ?? getPath(packet, "target.route");
+  return typeof value === "string" && value.trim() ? value : null;
+};
+var selectedMixProfileId = (packet) => {
+  const value = getPath(packet, "recommendation.candidate.summary.mixProfile.id") ?? getPath(packet, "baseline.mixProfile.id") ?? getPath(packet, "target.mixProfile.id");
+  return typeof value === "string" && value.trim() ? value : null;
+};
+function createDurableCandidatePatchPlan(proofOrPacket, options = {}) {
+  const packet = requireHumanReviewPacket(proofOrPacket);
+  const recommendation = asRecord(packet.recommendation);
+  const candidate = asRecord(recommendation.candidate);
+  const action = asRecord(candidate.action);
+  const guardrails = asRecord(packet.guardrails);
+  const request = asRecord(packet.request);
+  const approval = asRecord(request.approval);
+  const ranking = asRecord(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 ${formatValue(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 ${formatValue(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: ${formatCodeValue(plan.status)}`,
+    `- ok: ${formatCodeValue(plan.ok)}`,
+    `- target_label: ${formatValue(plan.target.label)}`,
+    `- mix_profile_id: ${formatCodeValue(plan.target.mixProfileId)}`,
+    `- source_file: ${formatCodeValue(plan.durableEdit?.sourceFile)}`,
+    "",
+    "## Candidate",
+    "",
+    `- label: ${formatCodeValue(plan.candidate.label)}`,
+    `- action: ${formatCodeValue(`${formatValue(plan.candidate.action.type)} ${formatValue(plan.candidate.action.track)}: ${formatValue(plan.candidate.action.from)} -> ${formatValue(plan.candidate.action.to)} (${formatValue(plan.candidate.action.delta)})`)}`,
+    "",
+    "## Approval Boundary",
+    "",
+    `- approval_mode: ${formatCodeValue(plan.approval.mode)}`,
+    `- approved_by: ${formatCodeValue(plan.approval.approvedBy)}`,
+    `- basis: ${formatValue(plan.approval.basis)}`,
+    `- boundary: ${formatValue(plan.boundary)}`,
+    "",
+    "## Durable Edit",
+    "",
+    `- mixer_levels: ${formatCodeValue(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
+  };
+}
+
+// src/durableCandidatePlanCli.ts
+var DEFAULT_JSON_NAME = "durable-candidate-patch-plan.json";
+var DEFAULT_MARKDOWN_NAME = "durable-candidate-patch-plan.md";
+var USAGE = `riddle-proof-durable-candidate-plan --proof <path|-> [options]
+
+Validate an applied human_review_packet and write a durable candidate patch
+plan. This is a handoff artifact, not proof of subjective quality.
+
+Options:
+  --proof <path|->       Riddle Proof proof.json/profile-result.json, packet JSON, or '-' for stdin.
+  --output <dir>         Output directory. Defaults to the proof file directory.
+  --json <path>          JSON output path. Defaults to <output>/durable-candidate-patch-plan.json.
+  --markdown <path>      Markdown output path. Defaults to <output>/durable-candidate-patch-plan.md.
+  --title <title>        Markdown title. Defaults to "Durable Candidate Patch Plan".
+  --source-file <path>   Optional source file where the durable edit should be applied.
+  --require-mix-profile  Require a mixProfileId before reporting ready_for_durable_patch.
+  --stdout              Also print the Markdown handoff to stdout.
+  --help                Show this help.
+`;
+var readValue = (argv, index, name) => {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`${name} requires a value.`);
+  return value;
+};
+function parseDurableCandidatePlanCliArgs(argv) {
+  const parsed = {
+    help: false,
+    proofPath: null,
+    outputDir: null,
+    jsonPath: null,
+    markdownPath: null,
+    title: null,
+    sourceFile: null,
+    requireMixProfileId: false,
+    stdout: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg === "--proof" || arg === "--packet") {
+      parsed.proofPath = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--output" || arg === "--output-dir") {
+      parsed.outputDir = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--json") {
+      parsed.jsonPath = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--markdown" || arg === "--md") {
+      parsed.markdownPath = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--title") {
+      parsed.title = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--source-file") {
+      parsed.sourceFile = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--require-mix-profile") {
+      parsed.requireMixProfileId = true;
+      continue;
+    }
+    if (arg === "--stdout") {
+      parsed.stdout = true;
+      continue;
+    }
+    if (!arg.startsWith("--") && !parsed.proofPath) {
+      parsed.proofPath = arg;
+      continue;
+    }
+    throw new Error(`Unknown argument ${arg}.`);
+  }
+  return parsed;
+}
+var readProofArtifact = (proofPath) => {
+  if (proofPath === "-") return JSON.parse((0, import_node_fs.readFileSync)(0, "utf8"));
+  const absoluteProofPath = import_node_path.default.resolve(proofPath);
+  if (!(0, import_node_fs.existsSync)(absoluteProofPath)) {
+    throw new Error(`Proof artifact not found: ${absoluteProofPath}`);
+  }
+  return JSON.parse((0, import_node_fs.readFileSync)(absoluteProofPath, "utf8"));
+};
+var outputDirFor = (proofPath, outputDir) => {
+  if (outputDir) return import_node_path.default.resolve(outputDir);
+  if (proofPath === "-") return process.cwd();
+  return import_node_path.default.dirname(import_node_path.default.resolve(proofPath));
+};
+function writeDurableCandidatePlanFiles({
+  proofPath,
+  outputDir,
+  jsonPath,
+  markdownPath,
+  title,
+  sourceFile,
+  requireMixProfileId
+}) {
+  const proof = readProofArtifact(proofPath);
+  const artifacts = createDurableCandidatePatchPlanArtifacts(proof, {
+    title: title ?? void 0,
+    sourceFile: sourceFile ?? void 0,
+    requireMixProfileId
+  });
+  const resolvedOutputDir = outputDirFor(proofPath, outputDir);
+  const resolvedJsonPath = import_node_path.default.resolve(jsonPath ?? import_node_path.default.join(resolvedOutputDir, DEFAULT_JSON_NAME));
+  const resolvedMarkdownPath = import_node_path.default.resolve(markdownPath ?? import_node_path.default.join(resolvedOutputDir, DEFAULT_MARKDOWN_NAME));
+  (0, import_node_fs.mkdirSync)(import_node_path.default.dirname(resolvedJsonPath), { recursive: true });
+  (0, import_node_fs.mkdirSync)(import_node_path.default.dirname(resolvedMarkdownPath), { recursive: true });
+  (0, import_node_fs.writeFileSync)(resolvedJsonPath, artifacts.json);
+  (0, import_node_fs.writeFileSync)(resolvedMarkdownPath, artifacts.markdown);
+  return {
+    ...artifacts,
+    jsonPath: resolvedJsonPath,
+    markdownPath: resolvedMarkdownPath
+  };
+}
+async function main(argv = process.argv.slice(2)) {
+  const args = parseDurableCandidatePlanCliArgs(argv);
+  if (args.help) {
+    (0, import_node_fs.writeFileSync)(1, USAGE);
+    return;
+  }
+  if (!args.proofPath) throw new Error("--proof is required.");
+  const result = writeDurableCandidatePlanFiles({
+    proofPath: args.proofPath,
+    outputDir: args.outputDir,
+    jsonPath: args.jsonPath,
+    markdownPath: args.markdownPath,
+    title: args.title,
+    sourceFile: args.sourceFile,
+    requireMixProfileId: args.requireMixProfileId
+  });
+  if (args.stdout) {
+    (0, import_node_fs.writeFileSync)(1, result.markdown);
+  } else {
+    (0, import_node_fs.writeFileSync)(1, `${JSON.stringify({
+      ok: result.plan.ok,
+      status: result.plan.status,
+      json: result.jsonPath,
+      markdown: result.markdownPath,
+      sourceFile: result.plan.durableEdit?.sourceFile ?? null,
+      errors: result.plan.errors
+    }, null, 2)}
+`);
+  }
+  if (!result.plan.ok) process.exitCode = 2;
+}
+main().catch((error) => {
+  (0, import_node_fs.writeFileSync)(2, `${error instanceof Error ? error.message : String(error)}
+`);
+  process.exitCode = 1;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main,
+  parseDurableCandidatePlanCliArgs,
+  writeDurableCandidatePlanFiles
+});

package/dist/durableCandidatePlanCli.d.cts

@@ -0,0 +1,32 @@
+import { D as DurableCandidatePatchPlan } from './durableCandidatePlan-Dv2P33Wg.cjs';
+
+interface ParsedArgs {
+    help: boolean;
+    proofPath: string | null;
+    outputDir: string | null;
+    jsonPath: string | null;
+    markdownPath: string | null;
+    title: string | null;
+    sourceFile: string | null;
+    requireMixProfileId: boolean;
+    stdout: boolean;
+}
+declare function parseDurableCandidatePlanCliArgs(argv: string[]): ParsedArgs;
+declare function writeDurableCandidatePlanFiles({ proofPath, outputDir, jsonPath, markdownPath, title, sourceFile, requireMixProfileId, }: {
+    proofPath: string;
+    outputDir: string | null;
+    jsonPath: string | null;
+    markdownPath: string | null;
+    title: string | null;
+    sourceFile: string | null;
+    requireMixProfileId: boolean;
+}): {
+    jsonPath: string;
+    markdownPath: string;
+    plan: DurableCandidatePatchPlan;
+    json: string;
+    markdown: string;
+};
+declare function main(argv?: string[]): Promise<void>;
+
+export { main, parseDurableCandidatePlanCliArgs, writeDurableCandidatePlanFiles };

package/dist/durableCandidatePlanCli.d.ts

@@ -0,0 +1,32 @@
+import { D as DurableCandidatePatchPlan } from './durableCandidatePlan-Dv2P33Wg.js';
+
+interface ParsedArgs {
+    help: boolean;
+    proofPath: string | null;
+    outputDir: string | null;
+    jsonPath: string | null;
+    markdownPath: string | null;
+    title: string | null;
+    sourceFile: string | null;
+    requireMixProfileId: boolean;
+    stdout: boolean;
+}
+declare function parseDurableCandidatePlanCliArgs(argv: string[]): ParsedArgs;
+declare function writeDurableCandidatePlanFiles({ proofPath, outputDir, jsonPath, markdownPath, title, sourceFile, requireMixProfileId, }: {
+    proofPath: string;
+    outputDir: string | null;
+    jsonPath: string | null;
+    markdownPath: string | null;
+    title: string | null;
+    sourceFile: string | null;
+    requireMixProfileId: boolean;
+}): {
+    jsonPath: string;
+    markdownPath: string;
+    plan: DurableCandidatePatchPlan;
+    json: string;
+    markdown: string;
+};
+declare function main(argv?: string[]): Promise<void>;
+
+export { main, parseDurableCandidatePlanCliArgs, writeDurableCandidatePlanFiles };

package/dist/durableCandidatePlanCli.js

@@ -0,0 +1,177 @@
+import {
+  createDurableCandidatePatchPlanArtifacts
+} from "./chunk-VFPSPQD7.js";
+import "./chunk-SAE6HFAG.js";
+
+// src/durableCandidatePlanCli.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import path from "path";
+var DEFAULT_JSON_NAME = "durable-candidate-patch-plan.json";
+var DEFAULT_MARKDOWN_NAME = "durable-candidate-patch-plan.md";
+var USAGE = `riddle-proof-durable-candidate-plan --proof <path|-> [options]
+
+Validate an applied human_review_packet and write a durable candidate patch
+plan. This is a handoff artifact, not proof of subjective quality.
+
+Options:
+  --proof <path|->       Riddle Proof proof.json/profile-result.json, packet JSON, or '-' for stdin.
+  --output <dir>         Output directory. Defaults to the proof file directory.
+  --json <path>          JSON output path. Defaults to <output>/durable-candidate-patch-plan.json.
+  --markdown <path>      Markdown output path. Defaults to <output>/durable-candidate-patch-plan.md.
+  --title <title>        Markdown title. Defaults to "Durable Candidate Patch Plan".
+  --source-file <path>   Optional source file where the durable edit should be applied.
+  --require-mix-profile  Require a mixProfileId before reporting ready_for_durable_patch.
+  --stdout              Also print the Markdown handoff to stdout.
+  --help                Show this help.
+`;
+var readValue = (argv, index, name) => {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`${name} requires a value.`);
+  return value;
+};
+function parseDurableCandidatePlanCliArgs(argv) {
+  const parsed = {
+    help: false,
+    proofPath: null,
+    outputDir: null,
+    jsonPath: null,
+    markdownPath: null,
+    title: null,
+    sourceFile: null,
+    requireMixProfileId: false,
+    stdout: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg === "--proof" || arg === "--packet") {
+      parsed.proofPath = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--output" || arg === "--output-dir") {
+      parsed.outputDir = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--json") {
+      parsed.jsonPath = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--markdown" || arg === "--md") {
+      parsed.markdownPath = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--title") {
+      parsed.title = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--source-file") {
+      parsed.sourceFile = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--require-mix-profile") {
+      parsed.requireMixProfileId = true;
+      continue;
+    }
+    if (arg === "--stdout") {
+      parsed.stdout = true;
+      continue;
+    }
+    if (!arg.startsWith("--") && !parsed.proofPath) {
+      parsed.proofPath = arg;
+      continue;
+    }
+    throw new Error(`Unknown argument ${arg}.`);
+  }
+  return parsed;
+}
+var readProofArtifact = (proofPath) => {
+  if (proofPath === "-") return JSON.parse(readFileSync(0, "utf8"));
+  const absoluteProofPath = path.resolve(proofPath);
+  if (!existsSync(absoluteProofPath)) {
+    throw new Error(`Proof artifact not found: ${absoluteProofPath}`);
+  }
+  return JSON.parse(readFileSync(absoluteProofPath, "utf8"));
+};
+var outputDirFor = (proofPath, outputDir) => {
+  if (outputDir) return path.resolve(outputDir);
+  if (proofPath === "-") return process.cwd();
+  return path.dirname(path.resolve(proofPath));
+};
+function writeDurableCandidatePlanFiles({
+  proofPath,
+  outputDir,
+  jsonPath,
+  markdownPath,
+  title,
+  sourceFile,
+  requireMixProfileId
+}) {
+  const proof = readProofArtifact(proofPath);
+  const artifacts = createDurableCandidatePatchPlanArtifacts(proof, {
+    title: title ?? void 0,
+    sourceFile: sourceFile ?? void 0,
+    requireMixProfileId
+  });
+  const resolvedOutputDir = outputDirFor(proofPath, outputDir);
+  const resolvedJsonPath = path.resolve(jsonPath ?? path.join(resolvedOutputDir, DEFAULT_JSON_NAME));
+  const resolvedMarkdownPath = path.resolve(markdownPath ?? path.join(resolvedOutputDir, DEFAULT_MARKDOWN_NAME));
+  mkdirSync(path.dirname(resolvedJsonPath), { recursive: true });
+  mkdirSync(path.dirname(resolvedMarkdownPath), { recursive: true });
+  writeFileSync(resolvedJsonPath, artifacts.json);
+  writeFileSync(resolvedMarkdownPath, artifacts.markdown);
+  return {
+    ...artifacts,
+    jsonPath: resolvedJsonPath,
+    markdownPath: resolvedMarkdownPath
+  };
+}
+async function main(argv = process.argv.slice(2)) {
+  const args = parseDurableCandidatePlanCliArgs(argv);
+  if (args.help) {
+    writeFileSync(1, USAGE);
+    return;
+  }
+  if (!args.proofPath) throw new Error("--proof is required.");
+  const result = writeDurableCandidatePlanFiles({
+    proofPath: args.proofPath,
+    outputDir: args.outputDir,
+    jsonPath: args.jsonPath,
+    markdownPath: args.markdownPath,
+    title: args.title,
+    sourceFile: args.sourceFile,
+    requireMixProfileId: args.requireMixProfileId
+  });
+  if (args.stdout) {
+    writeFileSync(1, result.markdown);
+  } else {
+    writeFileSync(1, `${JSON.stringify({
+      ok: result.plan.ok,
+      status: result.plan.status,
+      json: result.jsonPath,
+      markdown: result.markdownPath,
+      sourceFile: result.plan.durableEdit?.sourceFile ?? null,
+      errors: result.plan.errors
+    }, null, 2)}
+`);
+  }
+  if (!result.plan.ok) process.exitCode = 2;
+}
+main().catch((error) => {
+  writeFileSync(2, `${error instanceof Error ? error.message : String(error)}
+`);
+  process.exitCode = 1;
+});
+export {
+  main,
+  parseDurableCandidatePlanCliArgs,
+  writeDurableCandidatePlanFiles
+};