@nk070281sjv/cli 2.3.27 → 2.3.31

package/dist/index.js

@@ -30775,7 +30775,7 @@ ${hint}
 }
 
 // src/lib/version.ts
-var CLI_VERSION = true ? "2.3.27" : createRequire(import.meta.url)("../../package.json").version;
+var CLI_VERSION = true ? "2.3.31" : createRequire(import.meta.url)("../../package.json").version;
 
 // src/lib/deps.ts
 init_src();
@@ -35280,6 +35280,7 @@ function validateReviewer(value, path2, errors) {
   stringValue(obj.model, `${path2}.model`, errors);
   stringValue(obj.promptPath, `${path2}.promptPath`, errors);
   stringValue(obj.reviewPath, `${path2}.reviewPath`, errors);
+  stringValue(obj.promptId, `${path2}.promptId`, errors);
 }
 function validatePipelineArtifactRef(value, path2, errors) {
   const obj = object(value, path2, errors);
@@ -37417,6 +37418,7 @@ function extractVendorSessionId(events) {
 
 // src/lib/agent-orchestrator/review-orchestrator.ts
 import { existsSync as existsSync22, statSync as statSync5, readFileSync as readFileSync16 } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
 import { join as join27 } from "node:path";
 
 // src/lib/agent-orchestrator/artifact-writer.ts
@@ -37957,6 +37959,7 @@ function isRecord(value) {
 
 // src/lib/agent-orchestrator/prompt-writer.ts
 import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { createHash } from "node:crypto";
 import { dirname as dirname11, join as join26, relative as relative3 } from "node:path";
 async function writePromptSnapshots(input) {
   const promptsDir = join26(input.context.roundDir, "prompts");
@@ -37973,9 +37976,10 @@ async function writePromptSnapshots(input) {
     }
     const promptPath = `prompts/${reviewer.persona}-${reviewer.instance_index}.md`;
     const reviewPath = `reviews/${reviewer.persona}-${reviewer.instance_index}.md`;
+    const promptId = reviewerPromptId(input.context, reviewer, promptPath);
     await writeFile3(
       join26(input.context.roundDir, promptPath),
-      await reviewerPrompt(input.context, reviewer, promptPath, reviewPath, sharedReviewerPrefix),
+      await reviewerPrompt(input.context, reviewer, promptPath, reviewPath, sharedReviewerPrefix, promptId),
       "utf-8"
     );
     reviewers.push({
@@ -37983,13 +37987,14 @@ async function writePromptSnapshots(input) {
       instance: reviewer.instance_index,
       model: reviewer.model,
       promptPath,
-      reviewPath
+      reviewPath,
+      promptId
     });
   }
   const pipeline = {
     aggregation: await writePipelinePrompt(input, "aggregation", "aggregation.md"),
     validation: await writePipelinePrompt(input, "validation", "validation.md"),
-    synthesis: await writePipelinePrompt(input, "synthesis", "final.md"),
+    synthesis: await writePipelinePrompt(input, "synthesis", "synthesis.md"),
     translation_uk: await writePipelinePrompt(input, "translation_uk", "final.uk.md")
   };
   const resolvedTeam = {
@@ -38017,7 +38022,7 @@ async function writePipelinePrompt(input, stage, artifactPath) {
     artifactPath
   };
 }
-async function reviewerPrompt(context, reviewer, promptPath, reviewPath, sharedPrefix) {
+async function reviewerPrompt(context, reviewer, promptPath, reviewPath, sharedPrefix, promptId) {
   const personaPath = reviewerPersonaPath(context, reviewer);
   const personaContent = await readTextFile(personaPath);
   return [
@@ -38027,6 +38032,7 @@ async function reviewerPrompt(context, reviewer, promptPath, reviewPath, sharedP
     `Reviewer id: ${reviewer.persona}-${reviewer.instance_index}`,
     `Agent identity: ${reviewer.name}`,
     `Model alias and resolved model: ${reviewer.model}`,
+    `OCR prompt id: ${promptId}`,
     "",
     "## Reviewer Persona",
     "",
@@ -38041,8 +38047,9 @@ async function reviewerPrompt(context, reviewer, promptPath, reviewPath, sharedP
     "- Persona focus areas are for detecting issues only; this output contract overrides any persona request to propose fixes or broad guidance.",
     "",
     "Output contract:",
-    `- Return review markdown through stdout for ${reviewPath}.`,
-    "- Return only one fenced ```ocr-json block and no prose outside it.",
+    `- Return the review artifact through stdout for ${reviewPath}.`,
+    "- Return exactly one fenced ```ocr-json block and no prose outside it.",
+    `- The ocr-json block must include top-level "prompt_id": "${promptId}".`,
     "- Include maximum 5 findings, sorted by severity and production impact.",
     "- No introductions, no progress narration, no endpoint tables, no code snippets, no broad summaries.",
     "- Include critical, high, and medium findings. Include low only when it has concrete runtime/user impact. Exclude info/style/theoretical-only items.",
@@ -38052,10 +38059,11 @@ async function reviewerPrompt(context, reviewer, promptPath, reviewPath, sharedP
     "- Do not claim skipped agents ran.",
     "",
     "Required ocr-json schema:",
-    "- Output exactly this compact JSON shape inside the fenced block:",
+    "- Output exactly this compact JSON shape inside a fenced ```ocr-json block:",
     "",
-    "```json",
+    "```ocr-json",
     "{",
+    `  "prompt_id": "${promptId}",`,
     '  "findings": [',
     "    {",
     '      "sev": "high",',
@@ -38081,6 +38089,18 @@ async function reviewerPrompt(context, reviewer, promptPath, reviewPath, sharedP
     ""
   ].join("\n");
 }
+function reviewerPromptId(context, reviewer, promptPath) {
+  const input = [
+    context.sessionId,
+    String(context.round),
+    reviewer.persona,
+    String(reviewer.instance_index),
+    reviewer.name,
+    reviewer.model,
+    promptPath
+  ].join("\n");
+  return `ocr-prompt:${createHash("sha256").update(input).digest("hex").slice(0, 24)}`;
+}
 async function reviewerSharedPrefix(context) {
   const sections = [
     "# OCR Reviewer Shared Context",
@@ -38179,22 +38199,25 @@ function pipelinePrompt(context, stage, agent, promptPath, artifactPath) {
     "Output contract:",
     `- Return markdown through stdout for ${artifactPath}.`,
     ...stage === "translation_uk" ? [
-      "- Translate the complete final review to Ukrainian.",
-      "- Preserve markdown structure, headings, bullets, code spans, file paths, line numbers, and the fenced ```ocr-json block exactly as data.",
-      "- Do not translate JSON field names, enum values, file paths, code identifiers, stack traces, commands, or model names.",
+      "- Translate the complete human final review to Ukrainian.",
+      "- Return only readable Ukrainian Markdown for a developer.",
+      "- Do not include ```ocr-json, JSON, analysis notes, verification notes, or progress narration.",
+      "- Preserve markdown structure, headings, bullets, code spans, file paths, line numbers, commands, and model names.",
       "- Do not add new findings, remove findings, change severity/category/verdict, or change counts."
     ] : stage === "aggregation" ? [
-      "- Return only one fenced ```ocr-json block and no prose outside it.",
+      "- Return exactly one fenced ```ocr-json block and no prose outside it.",
       "- Keep the output compact: at most 8 findings and at most 12 dropped entries.",
       "- Do not include code snippets, long quotes, markdown tables, or reviewer narrative.",
       "- Read the original reviewer files, but aggregate only their structured findings and concrete evidence."
-    ] : ["- Include exactly one fenced ```ocr-json block."],
+    ] : ["- Return exactly one fenced ```ocr-json block and no prose outside it."],
     "- Do not write files directly.",
     "",
     ...stage === "translation_uk" ? [
       "Translation contract:",
-      "- The output must be a Ukrainian-language version of final.md.",
-      "- Keep the original ocr-json block valid JSON and semantically identical.",
+      "- The output must be a Ukrainian-language version of final.md for humans.",
+      "- Start with the translated top-level heading.",
+      "- Do not wrap the answer in a markdown code fence.",
+      "- Do not include JSON or machine-readable metadata.",
       ""
     ] : ["Required ocr-json schema:", schemaHint(stage), ""],
     "Forbidden behavior:",
@@ -38205,7 +38228,7 @@ function pipelinePrompt(context, stage, agent, promptPath, artifactPath) {
 }
 function schemaHint(stage) {
   if (stage === "translation_uk") {
-    return "No new schema. Preserve the existing final.md ocr-json block exactly.";
+    return "No machine schema. Produce human-readable Ukrainian Markdown only.";
   }
   if (stage === "aggregation") {
     return [
@@ -38219,7 +38242,7 @@ function schemaHint(stage) {
       "  - Keep low only when duplicated by 2+ reviewers or when it has concrete production/runtime impact.",
       "  - Drop info, style, theoretical-only, and future-extensibility-only items.",
       "",
-      "```json",
+      "```ocr-json",
       "{",
       '  "findings": [',
       "    {",
@@ -38261,7 +38284,7 @@ function schemaHint(stage) {
       "- Verify claims against the actual code before confirming. Do not trust reviewer text without code evidence.",
       "- Put every aggregation finding into exactly one of `confirmed`, `downgraded`, or `rejected`.",
       "",
-      "```json",
+      "```ocr-json",
       "{",
       '  "confirmed": [',
       "    {",
@@ -38303,7 +38326,7 @@ function schemaHint(stage) {
     "- Write developer-facing findings from validation results, not from unvalidated reviewer claims.",
     "- Include only confirmed and downgraded issues that a developer can act on.",
     "",
-    "```json",
+    "```ocr-json",
     "{",
     '  "verdict": "REQUEST CHANGES",',
     '  "synthesis_counts": {',
@@ -38432,7 +38455,48 @@ async function runReviewerPhase(input) {
   } finally {
     clearInterval(progressTimer);
   }
-  const failed = results.find((result) => result.exitCode !== 0);
+  const byId = new Map(input.resolvedTeam.reviewers.map((reviewer) => [
+    `${reviewer.type}-${reviewer.instance}`,
+    reviewer
+  ]));
+  const sortedResults = sortResults(results, requests);
+  const reviewerArtifacts = /* @__PURE__ */ new Map();
+  const artifactStatuses = [];
+  let failed = sortedResults.find((result) => result.exitCode !== 0);
+  let validationFailure;
+  for (const result of sortedResults) {
+    const reviewer = byId.get(result.id);
+    if (!reviewer) continue;
+    if (result.exitCode !== 0) {
+      artifactStatuses.push({
+        id: result.id,
+        exit_code: result.exitCode,
+        artifact_written: false
+      });
+      continue;
+    }
+    const validated = normalizeReviewerArtifact(processOutput(result), reviewer.promptId);
+    if (!validated.ok) {
+      validationFailure ??= { result, errors: validated.errors };
+      artifactStatuses.push({
+        id: result.id,
+        exit_code: 1,
+        artifact_written: false,
+        validation_errors: validated.errors
+      });
+      continue;
+    }
+    reviewerArtifacts.set(reviewer.reviewPath, validated.artifact);
+    artifactStatuses.push({
+      id: result.id,
+      exit_code: result.exitCode,
+      artifact_written: true,
+      artifact_path: join27(input.context.roundDir, reviewer.reviewPath)
+    });
+  }
+  for (const [reviewPath, artifact] of reviewerArtifacts) {
+    await writeRoundArtifact(input.context.roundDir, reviewPath, artifact);
+  }
   if (failed) {
     const failedRequest = requests.find((request) => request.id === failed.id);
     const diagnostic = buildFailureDiagnostic(failed, failedRequest);
@@ -38451,9 +38515,11 @@ async function runReviewerPhase(input) {
           diagnostic,
           stderr: failed.stderr,
           stdout_excerpt: excerpt(failed.stdout),
-          results: sortResults(results, requests).map((result) => ({
-            id: result.id,
-            exit_code: result.exitCode
+          artifact_statuses: artifactStatuses,
+          results: artifactStatuses.map((status) => ({
+            id: status.id,
+            exit_code: status.exit_code,
+            artifact_written: status.artifact_written
           }))
         },
         null,
@@ -38474,71 +38540,54 @@ async function runReviewerPhase(input) {
         ...diagnostic.stderr_excerpt ? [`stderr: ${diagnostic.stderr_excerpt}`] : [],
         ...diagnostic.stdout_excerpt ? [`stdout: ${diagnostic.stdout_excerpt}`] : []
       ],
-      results: sortResults(results, requests)
+      results: sortedResults
     };
   }
-  const byId = new Map(input.resolvedTeam.reviewers.map((reviewer) => [
-    `${reviewer.type}-${reviewer.instance}`,
-    reviewer
-  ]));
-  const reviewerArtifacts = /* @__PURE__ */ new Map();
-  for (const result of sortResults(results, requests)) {
-    const reviewer = byId.get(result.id);
-    if (!reviewer) continue;
-    const validated = normalizeReviewerArtifact(processOutput(result));
-    if (!validated.ok) {
-      const failedResult = { ...result, exitCode: 1 };
-      await writeRoundArtifact(
-        input.context.roundDir,
-        "failure-summary.json",
-        JSON.stringify(
-          {
-            schema_version: 1,
-            phase: "reviews",
-            failed_id: result.id,
-            exit_code: 1,
-            model: requests.find((request) => request.id === result.id)?.model,
-            prompt_path: requests.find((request) => request.id === result.id)?.promptPath,
-            cwd: requests.find((request) => request.id === result.id)?.cwd,
-            diagnostic: {
-              summary: "Reviewer output did not contain a valid compact ocr-json artifact. OCR refused to pass prose, plan-mode text, or malformed JSON into aggregation.",
-              hint: "Inspect the saved reviewer prompt and process log. The reviewer must return exactly one fenced ```ocr-json block with structured findings.",
-              stdout_excerpt: excerpt(processOutput(result))
-            },
-            stderr: result.stderr,
-            stdout_excerpt: excerpt(result.stdout),
-            validation_errors: validated.errors,
-            results: sortResults(
-              results.map((item) => item.id === result.id ? failedResult : item),
-              requests
-            ).map((item) => ({
-              id: item.id,
-              exit_code: item.exitCode
-            }))
+  if (validationFailure) {
+    const failedResult = { ...validationFailure.result, exitCode: 1 };
+    const failureResults = sortedResults.map((item) => item.id === failedResult.id ? failedResult : item);
+    await writeRoundArtifact(
+      input.context.roundDir,
+      "failure-summary.json",
+      JSON.stringify(
+        {
+          schema_version: 1,
+          phase: "reviews",
+          failed_id: validationFailure.result.id,
+          exit_code: 1,
+          model: requests.find((request) => request.id === validationFailure.result.id)?.model,
+          prompt_path: requests.find((request) => request.id === validationFailure.result.id)?.promptPath,
+          cwd: requests.find((request) => request.id === validationFailure.result.id)?.cwd,
+          diagnostic: {
+            summary: "Reviewer output did not contain a valid compact ocr-json artifact. OCR refused to pass prose, plan-mode text, or malformed JSON into aggregation.",
+            hint: "Inspect the saved reviewer prompt and process log. The reviewer must return exactly one fenced ```ocr-json block with structured findings.",
+            stdout_excerpt: excerpt(processOutput(validationFailure.result))
           },
-          null,
-          2
-        )
-      );
-      return {
-        ok: false,
-        failedId: result.id,
-        errors: [
-          `Reviewer ${result.id} produced invalid ocr-json output.`,
-          ...validated.errors
-        ],
-        results: sortResults(
-          results.map((item) => item.id === result.id ? failedResult : item),
-          requests
-        )
-      };
-    }
-    reviewerArtifacts.set(reviewer.reviewPath, validated.artifact);
-  }
-  for (const [reviewPath, artifact] of reviewerArtifacts) {
-    await writeRoundArtifact(input.context.roundDir, reviewPath, artifact);
+          stderr: validationFailure.result.stderr,
+          stdout_excerpt: excerpt(validationFailure.result.stdout),
+          validation_errors: validationFailure.errors,
+          artifact_statuses: artifactStatuses,
+          results: artifactStatuses.map((status) => ({
+            id: status.id,
+            exit_code: status.exit_code,
+            artifact_written: status.artifact_written
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return {
+      ok: false,
+      failedId: validationFailure.result.id,
+      errors: [
+        `Reviewer ${validationFailure.result.id} produced invalid ocr-json output.`,
+        ...validationFailure.errors
+      ],
+      results: failureResults
+    };
   }
-  return { ok: true, results: sortResults(results, requests) };
+  return { ok: true, results: sortedResults };
 }
 async function runOpenCodeProcessAgentReview(input) {
   const runner = input.runner ?? new OpenCodeProcessRunner();
@@ -38725,21 +38774,38 @@ async function runPipelineStages(input) {
         results
       };
     }
-    await writeRoundArtifact(input.context.roundDir, ref.artifactPath, processOutput(result));
-    const validationErrors = validateStageArtifact(input.context.roundDir, stage, ref.artifactPath);
-    if (validationErrors.length > 0) {
+    const normalizedArtifact = normalizeStageArtifact(processOutput(result));
+    if (!normalizedArtifact.ok) {
       await journal.endInstance(agentSessionId, {
         exitCode: 1,
-        note: validationErrors.join("\n")
+        note: normalizedArtifact.errors.join("\n")
       });
-      await writePipelineFailure(input.context.roundDir, stage, result, results, validationErrors);
+      await writePipelineFailure(input.context.roundDir, stage, result, results, normalizedArtifact.errors);
       return {
         ok: false,
         failedStage: stage,
-        errors: validationErrors,
+        errors: normalizedArtifact.errors,
         results
       };
     }
+    await writeRoundArtifact(input.context.roundDir, ref.artifactPath, normalizedArtifact.artifact);
+    const validation = validateStageArtifact(input.context.roundDir, stage, ref.artifactPath);
+    if (!validation.ok) {
+      await journal.endInstance(agentSessionId, {
+        exitCode: 1,
+        note: validation.errors.join("\n")
+      });
+      await writePipelineFailure(input.context.roundDir, stage, result, results, validation.errors);
+      return {
+        ok: false,
+        failedStage: stage,
+        errors: validation.errors,
+        results
+      };
+    }
+    if (stage === "synthesis") {
+      await writeRoundArtifact(input.context.roundDir, "final.md", renderHumanFinalReview(validation.value));
+    }
     await journal.endInstance(agentSessionId, { exitCode: 0 });
   }
   return { ok: true, results };
@@ -38834,15 +38900,8 @@ async function runUkrainianTranslation(input) {
     });
     return result;
   }
-  const sourceFinalMarkdown = readFileSync16(finalPath, "utf-8");
-  const translatedMarkdown = normalizeUkrainianTranslationOutput(
-    sourceFinalMarkdown,
-    processOutput(result)
-  );
-  const translationErrors = validateUkrainianTranslationOutput(
-    sourceFinalMarkdown,
-    translatedMarkdown
-  );
+  const translatedMarkdown = normalizeHumanMarkdownOutput(processOutput(result));
+  const translationErrors = validateUkrainianTranslationOutput(translatedMarkdown);
   if (translationErrors.length > 0) {
     await patchProcessMeta(input.context.roundDir, logPaths.meta, {
       status: "failed",
@@ -38862,7 +38921,7 @@ async function runUkrainianTranslation(input) {
           failed_id: request.id,
           exit_code: 1,
           diagnostic: {
-            summary: "Ukrainian translation output did not preserve the final review ocr-json block."
+            summary: "Ukrainian translation output was not a readable human Markdown final review."
           },
           validation_errors: translationErrors,
           stdout_excerpt: excerpt(result.stdout)
@@ -38900,23 +38959,21 @@ async function patchProcessMeta(roundDir, metaPath, patch) {
   }
   await writeRoundArtifact(roundDir, metaPath, JSON.stringify({ ...current, ...patch }, null, 2));
 }
-function validateUkrainianTranslationOutput(sourceMarkdown, translatedMarkdown) {
-  const sourceJson = extractOcrJsonBlock(sourceMarkdown);
-  if (!sourceJson.ok) return sourceJson.errors.map((error) => `source final.md: ${error}`);
-  const translatedJson = extractOcrJsonBlock(translatedMarkdown);
-  if (!translatedJson.ok) return translatedJson.errors.map((error) => `final.uk.md: ${error}`);
-  if (JSON.stringify(sourceJson.value) !== JSON.stringify(translatedJson.value)) {
-    return ["final.uk.md ocr-json block must be identical to final.md ocr-json block."];
+function validateUkrainianTranslationOutput(translatedMarkdown) {
+  const errors = [];
+  if (!translatedMarkdown.trim()) errors.push("final.uk.md must not be empty.");
+  if (/```ocr-json/i.test(translatedMarkdown) || /^\s*[{[]/.test(translatedMarkdown)) {
+    errors.push("final.uk.md must be human Markdown without JSON or ocr-json blocks.");
+  }
+  if (!translatedMarkdown.trimStart().startsWith("#")) {
+    errors.push("final.uk.md must start with a Markdown heading.");
   }
-  return [];
+  return errors;
 }
-function normalizeUkrainianTranslationOutput(sourceMarkdown, translatedMarkdown) {
-  const sourceBlock = extractOcrJsonFence(sourceMarkdown);
-  if (!sourceBlock) return translatedMarkdown;
-  const translatedWithoutJson = translatedMarkdown.replace(/```ocr-json[\s\S]*?```/g, "").trimEnd();
-  return `${translatedWithoutJson}
-
-${sourceBlock}
+function normalizeHumanMarkdownOutput(markdown) {
+  const trimmed = markdown.trim();
+  const fenced3 = trimmed.match(/^```(?:markdown|md)?\s*([\s\S]*?)```$/i);
+  return `${(fenced3?.[1] ?? trimmed).trimEnd()}
 `;
 }
 function extractOcrJsonFence(markdown) {
@@ -38930,15 +38987,61 @@ function sortResults(results, requests) {
 function validateStageArtifact(roundDir, stage, artifactPath) {
   const markdown = readFileSync16(join27(roundDir, artifactPath), "utf-8");
   const extracted = extractOcrJsonBlock(markdown);
-  if (!extracted.ok) return extracted.errors;
+  if (!extracted.ok) return extracted;
   const validated = stage === "aggregation" ? validateAggregationJson(extracted.value) : stage === "validation" ? validateValidationJson(extracted.value) : validateSynthesisJson(extracted.value);
-  return validated.ok ? [] : validated.errors;
+  return validated;
+}
+function normalizeStageArtifact(markdown) {
+  const extracted = extractOcrJsonBlock(markdown);
+  if (!extracted.ok) return extracted;
+  const fence = extractOcrJsonFence(markdown);
+  if (!fence) return { ok: false, errors: ["Expected exactly one fenced ```ocr-json block."] };
+  return { ok: true, artifact: `${fence}
+` };
+}
+function renderHumanFinalReview(synthesis) {
+  const grouped = {
+    blocker: synthesis.findings.filter((finding) => finding.category === "blocker"),
+    should_fix: synthesis.findings.filter((finding) => finding.category === "should_fix"),
+    suggestion: synthesis.findings.filter((finding) => finding.category === "suggestion"),
+    style: synthesis.findings.filter((finding) => finding.category === "style")
+  };
+  return [
+    "# OCR Final Review",
+    "",
+    `**Verdict:** ${synthesis.verdict}`,
+    "",
+    `**Counts:** ${synthesis.synthesis_counts.blockers} blocker(s), ${synthesis.synthesis_counts.should_fix} should-fix item(s), ${synthesis.synthesis_counts.suggestions} suggestion(s).`,
+    "",
+    ...renderFindingSection("Blockers", grouped.blocker),
+    ...renderFindingSection("Should Fix", grouped.should_fix),
+    ...renderFindingSection("Suggestions", grouped.suggestion),
+    ...renderFindingSection("Style", grouped.style)
+  ].join("\n").trimEnd() + "\n";
+}
+function renderFindingSection(title, findings) {
+  if (findings.length === 0) return [`## ${title}`, "", "None.", ""];
+  return [
+    `## ${title}`,
+    "",
+    ...findings.flatMap((finding, index) => [
+      `### ${index + 1}. ${finding.title}`,
+      "",
+      `- **Severity:** ${finding.severity}`,
+      `- **Location:** ${finding.file_path ?? "n/a"}${finding.line_start ? `:${finding.line_start}` : ""}${finding.line_end && finding.line_end !== finding.line_start ? `-${finding.line_end}` : ""}`,
+      `- **Issue:** ${finding.summary}`,
+      ...finding.flagged_by?.length ? [`- **Flagged by:** ${finding.flagged_by.join(", ")}`] : [],
+      ...finding.validation_source ? [`- **Validation:** ${finding.validation_source}`] : [],
+      ""
+    ])
+  ];
 }
 function isNonEmptyFile(path2) {
   return existsSync22(path2) && statSync5(path2).isFile() && statSync5(path2).size > 0;
 }
 async function writeProcessStartLog(roundDir, request) {
   const metaPath = `process-logs/${request.id}.meta.json`;
+  const promptMeta = readPromptMeta(request.promptPath);
   await writeRoundArtifact(
     roundDir,
     metaPath,
@@ -38949,6 +39052,7 @@ async function writeProcessStartLog(roundDir, request) {
         phase: request.phase,
         model: request.model,
         prompt_path: request.promptPath,
+        ...promptMeta,
         status: "running",
         started_at: (/* @__PURE__ */ new Date()).toISOString()
       },
@@ -38966,6 +39070,7 @@ async function writeProcessLogs(roundDir, request, result) {
   const absoluteMetaPath = join27(roundDir, metaPath);
   const startedAt = readStartedAt(absoluteMetaPath) ?? (/* @__PURE__ */ new Date()).toISOString();
   const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const promptMeta = readPromptMeta(request.promptPath);
   await writeRoundArtifact(roundDir, stdoutPath, result.stdout);
   await writeRoundArtifact(roundDir, stderrPath, result.stderr);
   await writeRoundArtifact(
@@ -38978,6 +39083,7 @@ async function writeProcessLogs(roundDir, request, result) {
         phase: request.phase,
         model: request.model,
         prompt_path: request.promptPath,
+        ...promptMeta,
         status: result.exitCode === 0 ? "completed" : "failed",
         started_at: startedAt,
         completed_at: completedAt,
@@ -38994,6 +39100,16 @@ async function writeProcessLogs(roundDir, request, result) {
   );
   return { stdout: stdoutPath, stderr: stderrPath, meta: metaPath };
 }
+function readPromptMeta(promptPath) {
+  if (!existsSync22(promptPath)) return {};
+  const prompt = readFileSync16(promptPath, "utf-8");
+  const bytes = Buffer.byteLength(prompt, "utf-8");
+  return {
+    prompt_sha256: createHash2("sha256").update(prompt).digest("hex"),
+    prompt_bytes: bytes,
+    prompt_delivery: prompt.length <= DEFAULT_PROMPT_ARGV_LIMIT ? "inline" : "file"
+  };
+}
 function readStartedAt(path2) {
   if (!existsSync22(path2)) return void 0;
   try {
@@ -39007,21 +39123,24 @@ function readStartedAt(path2) {
 function processOutput(result) {
   return result.outputText ?? result.stdout;
 }
-function normalizeReviewerArtifact(markdown) {
+function normalizeReviewerArtifact(markdown, expectedPromptId) {
   const extracted = extractOcrJsonBlock(markdown);
   if (!extracted.ok) return extracted;
-  const validationErrors = validateReviewerJson(extracted.value);
+  const validationErrors = validateReviewerJson(extracted.value, expectedPromptId);
   if (validationErrors.length > 0) return { ok: false, errors: validationErrors };
   const fence = extractOcrJsonFence(markdown);
   if (!fence) return { ok: false, errors: ["Expected exactly one fenced ```ocr-json block."] };
   return { ok: true, artifact: `${fence}
 ` };
 }
-function validateReviewerJson(value) {
+function validateReviewerJson(value, expectedPromptId) {
   const errors = [];
   if (!isRecord2(value)) {
     return ["Reviewer ocr-json must be an object."];
   }
+  if (value.prompt_id !== expectedPromptId) {
+    errors.push(`Reviewer ocr-json prompt_id must equal ${expectedPromptId}.`);
+  }
   if (!Array.isArray(value.findings)) {
     errors.push("Reviewer ocr-json findings must be an array.");
     return errors;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nk070281sjv/cli",
-  "version": "2.3.27",
+  "version": "2.3.31",
   "description": "CLI for Open Code Review - Multi-environment setup and progress tracking",
   "type": "module",
   "bin": {
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^7.2.0",
-    "@nk070281sjv/agents": "2.3.27",
+    "@nk070281sjv/agents": "2.3.31",
     "chalk": "^5.4.1",
     "chokidar": "^4.0.3",
     "commander": "^13.0.0",