@nk070281sjv/cli 2.3.11 → 2.3.17

package/README.md

@@ -69,6 +69,7 @@ pipeline_agents:
   aggregation: { model: big-brain }
   validation: { model: big-brain }
   synthesis: { model: big-brain }
+  translation_uk: { model: big-brain }
 ```
 
 Override per-review from the dashboard's Command Center, or via `--team` on the CLI. The dashboard auto-discovers every model your installed vendor (Claude Code or OpenCode) offers.
@@ -77,8 +78,14 @@ OpenCode reviews use `ocr review run-agents` internally. The CLI starts every
 resolved reviewer process, writes exact prompt snapshots under
 `rounds/round-{n}/prompts/`, writes reviewer stdout under `reviews/`, and then
 runs `aggregation`, `validation`, and `synthesis` as separate process agents.
+After `final.md` is written, it runs `translation_uk` and writes `final.uk.md`
+as a Ukrainian human-readable copy; translation failure is logged without
+invalidating the completed English review.
 If any configured reviewer or pipeline model is missing or any process fails,
 the round stops instead of continuing with a partial team or fabricated output.
+For normal OpenCode use, run `ocr review run-agents --fresh` without
+`--background`; the command keeps the shell call active, prints progress, and
+returns only when the review is completed or failed.
 
 ## Commands
 

package/dist/index.js

@@ -30779,7 +30779,7 @@ ${hint}
 }
 
 // src/lib/version.ts
-var CLI_VERSION = true ? "2.3.11" : createRequire(import.meta.url)("../../package.json").version;
+var CLI_VERSION = true ? "2.3.17" : createRequire(import.meta.url)("../../package.json").version;
 
 // src/lib/deps.ts
 init_src();
@@ -35260,7 +35260,7 @@ function validateResolvedTeamSnapshot(value) {
       validatePipelineArtifactRef(pipeline[stage], `pipeline.${stage}`, errors);
     }
     for (const key of Object.keys(pipeline)) {
-      if (!["aggregation", "validation", "synthesis"].includes(key)) {
+      if (!["aggregation", "validation", "synthesis", "translation_uk"].includes(key)) {
         errors.push(`pipeline.${key} is not a supported pipeline stage.`);
       }
     }
@@ -37234,6 +37234,12 @@ var import_yaml3 = __toESM(require_dist(), 1);
 import { existsSync as existsSync20, readFileSync as readFileSync15 } from "node:fs";
 import { join as join23 } from "node:path";
 var PIPELINE_STAGES = [
+  "aggregation",
+  "validation",
+  "synthesis",
+  "translation_uk"
+];
+var CORE_PIPELINE_STAGES = [
   "aggregation",
   "validation",
   "synthesis"
@@ -37275,9 +37281,14 @@ function readPipelineAgents(root, aliases) {
     throw new Error(`pipeline_agents: unknown stage(s): ${unknownKeys.join(", ")}`);
   }
   const out = {};
-  for (const stage of PIPELINE_STAGES) {
+  for (const stage of CORE_PIPELINE_STAGES) {
     out[stage] = readPipelineAgent(stage, obj[stage], aliases);
   }
+  out.translation_uk = obj.translation_uk ? readPipelineAgent("translation_uk", obj.translation_uk, aliases) : {
+    stage: "translation_uk",
+    model: out.synthesis.model,
+    requestedModel: out.synthesis.requestedModel
+  };
   return out;
 }
 function readPipelineAgent(stage, value, aliases) {
@@ -37420,7 +37431,8 @@ import { dirname as dirname10, join as join25 } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
-var GIT_SNAPSHOT_LIMIT = 2e4;
+var GIT_SUMMARY_LIMIT = 2e4;
+var GIT_PATCH_LIMIT = 8e4;
 var REVIEW_SNAPSHOT_EXCLUDES = [".ocr", ".opencode"];
 async function prepareReviewContext(input) {
   const roundDir = join25(input.sessionDir, "rounds", `round-${input.round}`);
@@ -37438,7 +37450,15 @@ async function prepareReviewContext(input) {
     "# Review Context\n\nNo shared review context has been recorded yet.\n"
   );
   const reviewBriefPath = join25(roundDir, "review-brief.md");
-  const gitSnapshot = input.cwd ? await collectGitSnapshot(input.cwd) : void 0;
+  const gitSnapshot = input.cwd ? await collectGitSnapshot(input.cwd, input.target) : void 0;
+  const diffPatchPath = gitSnapshot ? join25(roundDir, "diff.patch") : void 0;
+  if (gitSnapshot && diffPatchPath) {
+    await writeFile2(
+      diffPatchPath,
+      gitSnapshot.diffPatch || "No textual diff patch was captured by the CLI.\n",
+      "utf-8"
+    );
+  }
   await writeFile2(
     reviewBriefPath,
     [
@@ -37448,11 +37468,12 @@ async function prepareReviewContext(input) {
       `Round: ${input.round}`,
       `Discovered standards: ${discoveredStandardsPath}`,
       `Shared context: ${contextPath}`,
+      ...diffPatchPath ? [`Diff patch: ${diffPatchPath}`] : [],
       ...input.cwd ? [`Repository root: ${input.cwd}`] : [],
       "",
       "## Scope",
       "",
-      "Review the current working tree changes. Focus on changed files and the unchanged code needed to validate those changes.",
+      gitSnapshot?.baseRef ? `Review branch changes against ${gitSnapshot.baseRef}, plus current working tree changes. Focus on changed files and the unchanged code needed to validate those changes.` : "Review the current working tree changes. Focus on changed files and the unchanged code needed to validate those changes.",
       "Ignore local AI tooling/config churn under `.ocr/` and `.opencode/` unless the user explicitly asks to review OCR/OpenCode setup changes.",
       "",
       ...gitSnapshot ? [
@@ -37464,6 +37485,12 @@ async function prepareReviewContext(input) {
         "",
         fenced("text", gitSnapshot.changedFiles || "No changed files reported."),
         "",
+        ...gitSnapshot.baseRef ? [
+          "## Branch Base",
+          "",
+          fenced("text", gitSnapshot.baseRef),
+          ""
+        ] : [],
         "## Diff Stat",
         "",
         fenced("text", gitSnapshot.diffStat || "No diff stat available."),
@@ -37502,6 +37529,7 @@ async function prepareReviewContext(input) {
           discovered_standards: discoveredStandardsPath,
           context: contextPath,
           review_brief: reviewBriefPath,
+          ...diffPatchPath ? { diff_patch: diffPatchPath } : {},
           ...requirementsPath ? { requirements: requirementsPath } : {}
         }
       },
@@ -37518,39 +37546,110 @@ async function prepareReviewContext(input) {
     discoveredStandardsPath,
     contextPath,
     reviewBriefPath,
+    diffPatchPath,
     requirementsPath,
     metadataPath,
     requirementsExpected: Boolean(requirementsPath)
   };
 }
-async function collectGitSnapshot(cwd) {
-  const [status, cachedFiles, worktreeFiles, diffStat] = await Promise.all([
+async function collectGitSnapshot(cwd, target = ".") {
+  const explicitBase = target && target !== "." ? target : void 0;
+  const autoBase = explicitBase ? void 0 : await resolveDefaultRemoteBase(cwd);
+  const baseRef = explicitBase ?? autoBase;
+  const branchDiffArgs = baseRef ? [`${baseRef}...HEAD`, "--", ...gitReviewPathspec()] : void 0;
+  const [
+    status,
+    cachedFiles,
+    worktreeFiles,
+    untrackedFiles,
+    branchFiles,
+    worktreeDiffStat,
+    branchDiffStat,
+    worktreeDiffPatch,
+    branchDiffPatch
+  ] = await Promise.all([
     runGit(cwd, ["status", "--short"]),
     runGit(cwd, ["diff", "--cached", "--name-only", "--", ...gitReviewPathspec()]),
     runGit(cwd, ["diff", "--name-only", "HEAD", "--", ...gitReviewPathspec()]),
-    runGit(cwd, ["diff", "--stat", "HEAD", "--", ...gitReviewPathspec()])
+    runGit(cwd, ["ls-files", "--others", "--exclude-standard", "--", ...gitReviewPathspec()]),
+    branchDiffArgs ? runGit(cwd, ["diff", "--name-only", ...branchDiffArgs]) : Promise.resolve(""),
+    runGit(cwd, ["diff", "--stat", "HEAD", "--", ...gitReviewPathspec()]),
+    branchDiffArgs ? runGit(cwd, ["diff", "--stat", ...branchDiffArgs]) : Promise.resolve(""),
+    runGit(cwd, ["diff", "--patch", "HEAD", "--", ...gitReviewPathspec()], GIT_PATCH_LIMIT),
+    branchDiffArgs ? runGit(cwd, ["diff", "--patch", ...branchDiffArgs], GIT_PATCH_LIMIT) : Promise.resolve("")
   ]);
+  const untrackedFileList = filterIgnoredPaths(uniqueLines(untrackedFiles));
+  const untrackedDiffPatch = await collectUntrackedDiffPatch(cwd, untrackedFileList);
+  const changedFiles = filterIgnoredPaths(uniqueLines([
+    branchFiles,
+    cachedFiles,
+    worktreeFiles,
+    untrackedFileList
+  ].join("\n")));
+  const diffStat = uniqueSections([
+    branchDiffStat ? `Branch diff (${baseRef}...HEAD):
+${branchDiffStat}` : "",
+    worktreeDiffStat ? `Working tree diff (HEAD):
+${worktreeDiffStat}` : ""
+  ]);
+  const diffPatch = truncate(uniqueSections([
+    branchDiffPatch ? `Branch diff (${baseRef}...HEAD):
+${branchDiffPatch}` : "",
+    worktreeDiffPatch ? `Working tree diff (HEAD):
+${worktreeDiffPatch}` : "",
+    untrackedDiffPatch ? `Untracked files diff:
+${untrackedDiffPatch}` : ""
+  ]), GIT_PATCH_LIMIT);
   return {
     status: filterIgnoredStatusLines(status),
-    changedFiles: filterIgnoredPaths(uniqueLines(`${cachedFiles}
-${worktreeFiles}`)),
-    diffStat
+    changedFiles,
+    diffStat,
+    diffPatch,
+    baseRef
   };
 }
+async function collectUntrackedDiffPatch(cwd, files) {
+  const patches = [];
+  let remaining = GIT_PATCH_LIMIT;
+  for (const file of files.split(/\r?\n/).filter(Boolean)) {
+    if (remaining <= 0) {
+      patches.push("[truncated by OCR CLI]");
+      break;
+    }
+    const patch = await runGit(cwd, ["diff", "--no-index", "--", "/dev/null", file], remaining);
+    if (patch) {
+      patches.push(patch);
+      remaining -= patch.length;
+    }
+  }
+  return patches.join("\n\n");
+}
 function gitReviewPathspec() {
-  return [".", ...REVIEW_SNAPSHOT_EXCLUDES.map((path2) => `:(exclude)${path2}`)];
+  return [".", ...REVIEW_SNAPSHOT_EXCLUDES.flatMap((path2) => [
+    `:(exclude)${path2}`,
+    `:(exclude)${path2}/**`
+  ])];
+}
+async function resolveDefaultRemoteBase(cwd) {
+  const originHead = await runGit(cwd, ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]);
+  if (originHead) return originHead;
+  for (const candidate of ["origin/main", "origin/master", "origin/develop", "main", "master", "develop"]) {
+    const exists = await runGit(cwd, ["rev-parse", "--verify", "-q", candidate]);
+    if (exists) return candidate;
+  }
+  return void 0;
 }
-async function runGit(cwd, args) {
+async function runGit(cwd, args, limit = GIT_SUMMARY_LIMIT) {
   try {
     const { stdout, stderr } = await execFileAsync("git", args, {
       cwd,
-      maxBuffer: GIT_SNAPSHOT_LIMIT * 2
+      maxBuffer: limit * 2
     });
     return truncate(`${stdout}${stderr ? `
-${stderr}` : ""}`.trim());
+${stderr}` : ""}`.trim(), limit);
   } catch (error) {
     if (error && typeof error === "object" && "stdout" in error && typeof error.stdout === "string") {
-      return truncate(error.stdout.trim());
+      return truncate(error.stdout.trim(), limit);
     }
     return "";
   }
@@ -37559,6 +37658,9 @@ function uniqueLines(value) {
   const lines = value.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   return [...new Set(lines)].join("\n");
 }
+function uniqueSections(values) {
+  return values.filter((value) => value.trim() !== "").join("\n\n");
+}
 function filterIgnoredStatusLines(value) {
   return value.split(/\r?\n/).filter((line) => {
     const pathPart = line.slice(3).trim();
@@ -37574,9 +37676,9 @@ function isIgnoredReviewPath(path2) {
     (ignored) => normalized === ignored || normalized.startsWith(`${ignored}/`)
   );
 }
-function truncate(value) {
-  if (value.length <= GIT_SNAPSHOT_LIMIT) return value;
-  return `${value.slice(0, GIT_SNAPSHOT_LIMIT)}
+function truncate(value, limit) {
+  if (value.length <= limit) return value;
+  return `${value.slice(0, limit)}
 [truncated by OCR CLI]`;
 }
 function fenced(language, value) {
@@ -37869,13 +37971,14 @@ function isRecord(value) {
 }
 
 // src/lib/agent-orchestrator/prompt-writer.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname11, join as join26, relative as relative3 } from "node:path";
 async function writePromptSnapshots(input) {
   const promptsDir = join26(input.context.roundDir, "prompts");
   const reviewsDir = join26(input.context.roundDir, "reviews");
   await mkdir3(promptsDir, { recursive: true });
   await mkdir3(reviewsDir, { recursive: true });
+  const sharedReviewerPrefix = await reviewerSharedPrefix(input.context);
   const reviewers = [];
   for (const reviewer of input.reviewers) {
     if (!reviewer.model) {
@@ -37887,7 +37990,7 @@ async function writePromptSnapshots(input) {
     const reviewPath = `reviews/${reviewer.persona}-${reviewer.instance_index}.md`;
     await writeFile3(
       join26(input.context.roundDir, promptPath),
-      reviewerPrompt(input.context, reviewer, promptPath, reviewPath),
+      await reviewerPrompt(input.context, reviewer, promptPath, reviewPath, sharedReviewerPrefix),
       "utf-8"
     );
     reviewers.push({
@@ -37901,7 +38004,8 @@ async function writePromptSnapshots(input) {
   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", "final.md"),
+    translation_uk: await writePipelinePrompt(input, "translation_uk", "final.uk.md")
   };
   const resolvedTeam = {
     sessionId: input.context.sessionId,
@@ -37916,7 +38020,7 @@ async function writePromptSnapshots(input) {
 }
 async function writePipelinePrompt(input, stage, artifactPath) {
   const agent = input.pipelineAgents[stage];
-  const promptPath = `prompts/${stage}.md`;
+  const promptPath = `prompts/${displayStageName(stage)}.md`;
   await writeFile3(
     join26(input.context.roundDir, promptPath),
     pipelinePrompt(input.context, stage, agent, promptPath, artifactPath),
@@ -37928,33 +38032,22 @@ async function writePipelinePrompt(input, stage, artifactPath) {
     artifactPath
   };
 }
-function reviewerPrompt(context, reviewer, promptPath, reviewPath) {
+async function reviewerPrompt(context, reviewer, promptPath, reviewPath, sharedPrefix) {
+  const personaPath = reviewerPersonaPath(context, reviewer);
+  const personaContent = await readTextFile(personaPath);
   return [
-    `# Reviewer Agent: ${reviewer.persona}-${reviewer.instance_index}`,
+    sharedPrefix,
+    "# Reviewer-Specific Instructions",
     "",
+    `Reviewer id: ${reviewer.persona}-${reviewer.instance_index}`,
     `Agent identity: ${reviewer.name}`,
     `Model alias and resolved model: ${reviewer.model}`,
-    `Session id: ${context.sessionId}`,
-    `Round number: ${context.round}`,
-    "Phase: reviews",
+    `Persona source: ${personaPath}`,
+    `Relative persona source: ${relative3(context.roundDir, personaPath)}`,
     "",
-    "Input files to read before reviewing:",
-    `- ${reviewerPersonaPath(context, reviewer)}`,
-    `- ${context.discoveredStandardsPath}`,
-    `- ${context.contextPath}`,
-    `- ${context.reviewBriefPath}`,
-    ...context.requirementsPath ? [`- ${context.requirementsPath}`] : [],
+    "## Reviewer Persona",
     "",
-    "Input path rules:",
-    "- Read exactly the files listed above; they are session-scoped snapshots.",
-    "- Do not look for legacy root files such as .ocr/context.md, .ocr/discovered-standards.md, or .ocr/review-brief.md.",
-    "- If a listed file is missing, report that failure in stdout instead of searching for substitutes.",
-    "- Relative equivalents from the round directory:",
-    `  - ${relative3(context.roundDir, context.discoveredStandardsPath)}`,
-    `  - ${relative3(context.roundDir, context.contextPath)}`,
-    `  - ${relative3(context.roundDir, context.reviewBriefPath)}`,
-    `  - ${relative3(context.roundDir, reviewerPersonaPath(context, reviewer))}`,
-    ...context.requirementsPath ? [`  - ${relative3(context.roundDir, context.requirementsPath)}`] : [],
+    fenced2("markdown", personaContent),
     "",
     "Review focus:",
     "- Apply the reviewer persona file as your primary review lens.",
@@ -37975,15 +38068,72 @@ function reviewerPrompt(context, reviewer, promptPath, reviewPath) {
     ""
   ].join("\n");
 }
+async function reviewerSharedPrefix(context) {
+  const sections = [
+    "# OCR Reviewer Shared Context",
+    "",
+    "This prefix is intentionally identical for every reviewer in this round to improve prompt-cache locality.",
+    "",
+    "## Session",
+    "",
+    `Session id: ${context.sessionId}`,
+    `Round number: ${context.round}`,
+    "Phase: reviews",
+    `Session directory: ${context.sessionDir}`,
+    `Round directory: ${context.roundDir}`,
+    "",
+    "## Review Scope Rules",
+    "",
+    "- Review the changed application code described in the review brief.",
+    "- Ignore local AI tooling/config churn under `.ocr/` and `.opencode/` unless the user explicitly asks to review OCR/OpenCode setup changes.",
+    "- Inspect surrounding source code only when needed to validate a finding.",
+    "- Report only findings supported by code evidence and concrete file references.",
+    "- Prefer targeted `git diff -- <path>` and file reads over broad repository scans.",
+    "",
+    "## Source Files Embedded Below",
+    "",
+    `- Discovered standards: ${context.discoveredStandardsPath}`,
+    `- Shared context: ${context.contextPath}`,
+    `- Review brief: ${context.reviewBriefPath}`,
+    ...context.diffPatchPath ? [`- Diff patch: ${context.diffPatchPath}`] : [],
+    ...context.requirementsPath ? [`- Requirements: ${context.requirementsPath}`] : [],
+    "",
+    embeddedFileSection("Discovered Standards", context.discoveredStandardsPath, await readTextFile(context.discoveredStandardsPath)),
+    embeddedFileSection("Shared Review Context", context.contextPath, await readTextFile(context.contextPath)),
+    embeddedFileSection("Review Brief", context.reviewBriefPath, await readTextFile(context.reviewBriefPath)),
+    ...context.diffPatchPath ? [embeddedFileSection("Diff Patch", context.diffPatchPath, await readTextFile(context.diffPatchPath))] : [],
+    ...context.requirementsPath ? [embeddedFileSection("Requirements", context.requirementsPath, await readTextFile(context.requirementsPath))] : [],
+    ""
+  ];
+  return sections.join("\n");
+}
+function embeddedFileSection(title, path2, content) {
+  return [
+    `## ${title}`,
+    "",
+    `Source: ${path2}`,
+    "",
+    fenced2("markdown", content),
+    ""
+  ].join("\n");
+}
+function fenced2(language, value) {
+  return `\`\`\`${language}
+${value.trim()}
+\`\`\``;
+}
+async function readTextFile(path2) {
+  return readFile3(path2, "utf-8");
+}
 function reviewerPersonaPath(context, reviewer) {
   const ocrDir = dirname11(dirname11(context.sessionDir));
   return join26(ocrDir, "skills", "references", "reviewers", `${reviewer.persona}.md`);
 }
 function pipelinePrompt(context, stage, agent, promptPath, artifactPath) {
   return [
-    `# Pipeline Agent: ${stage}`,
+    `# Pipeline Agent: ${displayStageName(stage)}`,
     "",
-    `Agent identity: ${stage}`,
+    `Agent identity: ${displayStageName(stage)}`,
     `Model alias and resolved model: ${agent.requestedModel} -> ${agent.model}`,
     `Session id: ${context.sessionId}`,
     `Round number: ${context.round}`,
@@ -37993,9 +38143,11 @@ function pipelinePrompt(context, stage, agent, promptPath, artifactPath) {
     `- ${context.discoveredStandardsPath}`,
     `- ${context.contextPath}`,
     `- ${context.reviewBriefPath}`,
-    `- ${join26(context.roundDir, "reviews")}`,
-    ...stage !== "aggregation" ? [join26(context.roundDir, "aggregation.md")] : [],
-    ...stage === "synthesis" ? [join26(context.roundDir, "validation.md")] : [],
+    ...stage === "translation_uk" ? [join26(context.roundDir, "final.md")] : [
+      join26(context.roundDir, "reviews"),
+      ...stage !== "aggregation" ? [join26(context.roundDir, "aggregation.md")] : [],
+      ...stage === "synthesis" ? [join26(context.roundDir, "validation.md")] : []
+    ],
     "",
     "Input path rules:",
     "- Read exactly the files and directories listed above; they are session-scoped snapshots.",
@@ -38005,18 +38157,28 @@ function pipelinePrompt(context, stage, agent, promptPath, artifactPath) {
     `  - ${relative3(context.roundDir, context.discoveredStandardsPath)}`,
     `  - ${relative3(context.roundDir, context.contextPath)}`,
     `  - ${relative3(context.roundDir, context.reviewBriefPath)}`,
-    "  - reviews/",
-    ...stage !== "aggregation" ? ["  - aggregation.md"] : [],
-    ...stage === "synthesis" ? ["  - validation.md"] : [],
+    ...stage === "translation_uk" ? ["  - final.md"] : [
+      "  - reviews/",
+      ...stage !== "aggregation" ? ["  - aggregation.md"] : [],
+      ...stage === "synthesis" ? ["  - validation.md"] : []
+    ],
     "",
     "Output contract:",
     `- Return markdown through stdout for ${artifactPath}.`,
-    "- Include exactly one fenced ```ocr-json block.",
+    ...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.",
+      "- Do not add new findings, remove findings, change severity/category/verdict, or change counts."
+    ] : ["- Include exactly one fenced ```ocr-json block."],
     "- Do not write files directly.",
     "",
-    "Required ocr-json schema:",
-    schemaHint(stage),
-    "",
+    ...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.",
+      ""
+    ] : ["Required ocr-json schema:", schemaHint(stage), ""],
     "Forbidden behavior:",
     `- Do not modify ${promptPath} or ${artifactPath}.`,
     "- Do not pretend missing reviewer outputs exist.",
@@ -38024,6 +38186,9 @@ function pipelinePrompt(context, stage, agent, promptPath, artifactPath) {
   ].join("\n");
 }
 function schemaHint(stage) {
+  if (stage === "translation_uk") {
+    return "No new schema. Preserve the existing final.md ocr-json block exactly.";
+  }
   if (stage === "aggregation") {
     return [
       "AggregationJson:",
@@ -38141,6 +38306,9 @@ function schemaHint(stage) {
     "- `synthesis_counts` must exactly match the categories in `findings`."
   ].join("\n");
 }
+function displayStageName(stage) {
+  return stage === "translation_uk" ? "translation-uk" : stage;
+}
 
 // src/lib/agent-orchestrator/review-orchestrator.ts
 async function runReviewerPhase(input) {
@@ -38297,7 +38465,8 @@ async function runOpenCodeProcessAgentReview(input) {
       sessionDir: input.sessionDir,
       round: input.round,
       requirements: input.requirements,
-      cwd: input.cwd
+      cwd: input.cwd,
+      target: input.target
     });
     const snapshot = await writePromptSnapshots({
       context,
@@ -38358,12 +38527,23 @@ async function runOpenCodeProcessAgentReview(input) {
         errors: pipelineResult.errors
       };
     }
+    const translationResult = await runUkrainianTranslation({
+      context,
+      resolvedTeam: snapshot.resolvedTeam,
+      cwd: input.cwd,
+      runner,
+      journal,
+      emit
+    });
     emit({ event: "pipeline:complete", session_id: input.sessionId });
     return {
       ok: true,
       resolvedTeam: snapshot.resolvedTeam,
       reviewerResults: reviewerResult.results,
-      pipelineResults: pipelineResult.results
+      pipelineResults: [
+        ...pipelineResult.results,
+        ...translationResult ? [translationResult] : []
+      ]
     };
   } finally {
     await runner.close?.();
@@ -38478,6 +38658,167 @@ async function runPipelineStages(input) {
   }
   return { ok: true, results };
 }
+async function runUkrainianTranslation(input) {
+  const ref = input.resolvedTeam.pipeline.translation_uk;
+  const emit = input.emit ?? (() => void 0);
+  if (!ref) return void 0;
+  const finalPath = join27(input.context.roundDir, "final.md");
+  if (!isNonEmptyFile(finalPath)) return void 0;
+  const journal = input.journal ?? new NoopAgentLifecycleJournal();
+  const request = {
+    id: "translation-uk",
+    model: ref.model,
+    promptPath: join27(input.context.roundDir, ref.promptPath),
+    cwd: input.cwd,
+    phase: "translation_uk"
+  };
+  const agentSessionId = await journal.startInstance({
+    workflowId: input.context.sessionId,
+    persona: "pipeline",
+    instance: 1,
+    name: request.id,
+    model: ref.model,
+    phase: request.phase
+  });
+  await journal.beat(agentSessionId);
+  const startLogPaths = await writeProcessStartLog(input.context.roundDir, request);
+  emit({
+    event: "agent:start",
+    phase: request.phase,
+    id: request.id,
+    model: request.model,
+    prompt_path: request.promptPath,
+    meta_log: startLogPaths.meta
+  });
+  const progressTimer = setInterval(() => {
+    emit({
+      event: "agent:progress",
+      phase: request.phase,
+      id: request.id,
+      status: "running"
+    });
+  }, 15e3);
+  progressTimer.unref?.();
+  let result;
+  try {
+    result = await input.runner.run(request, new AbortController().signal);
+  } finally {
+    clearInterval(progressTimer);
+  }
+  const logPaths = await writeProcessLogs(input.context.roundDir, request, result);
+  emit({
+    event: "agent:complete",
+    phase: request.phase,
+    id: request.id,
+    exit_code: result.exitCode,
+    stdout_log: logPaths.stdout,
+    stderr_log: logPaths.stderr,
+    meta_log: logPaths.meta
+  });
+  const vendorId = extractVendorSessionId(result.ndjsonEvents);
+  if (vendorId) await journal.bindVendorId(agentSessionId, vendorId);
+  if (result.exitCode !== 0) {
+    const diagnostic = buildFailureDiagnostic(result, request);
+    await journal.endInstance(agentSessionId, {
+      exitCode: result.exitCode,
+      note: diagnostic.summary
+    });
+    await writeRoundArtifact(
+      input.context.roundDir,
+      "translation-uk-failure.json",
+      JSON.stringify(
+        {
+          schema_version: 1,
+          phase: "translation_uk",
+          failed_id: request.id,
+          exit_code: result.exitCode,
+          diagnostic,
+          stderr: result.stderr,
+          stdout_excerpt: excerpt(result.stdout)
+        },
+        null,
+        2
+      )
+    );
+    emit({
+      event: "translation:failed",
+      phase: request.phase,
+      id: request.id,
+      artifact_path: ref.artifactPath
+    });
+    return result;
+  }
+  const translationErrors = validateUkrainianTranslationOutput(
+    readFileSync16(finalPath, "utf-8"),
+    processOutput(result)
+  );
+  if (translationErrors.length > 0) {
+    await patchProcessMeta(input.context.roundDir, logPaths.meta, {
+      status: "failed",
+      validation_errors: translationErrors
+    });
+    await journal.endInstance(agentSessionId, {
+      exitCode: 1,
+      note: translationErrors.join("\n")
+    });
+    await writeRoundArtifact(
+      input.context.roundDir,
+      "translation-uk-failure.json",
+      JSON.stringify(
+        {
+          schema_version: 1,
+          phase: "translation_uk",
+          failed_id: request.id,
+          exit_code: 1,
+          diagnostic: {
+            summary: "Ukrainian translation output did not preserve the final review ocr-json block."
+          },
+          validation_errors: translationErrors,
+          stdout_excerpt: excerpt(result.stdout)
+        },
+        null,
+        2
+      )
+    );
+    emit({
+      event: "translation:failed",
+      phase: request.phase,
+      id: request.id,
+      artifact_path: ref.artifactPath
+    });
+    return { ...result, exitCode: 1 };
+  }
+  await writeRoundArtifact(input.context.roundDir, ref.artifactPath, processOutput(result));
+  await journal.endInstance(agentSessionId, { exitCode: 0 });
+  emit({
+    event: "translation:complete",
+    phase: request.phase,
+    id: request.id,
+    artifact_path: ref.artifactPath
+  });
+  return result;
+}
+async function patchProcessMeta(roundDir, metaPath, patch) {
+  const absolutePath = join27(roundDir, metaPath);
+  let current = {};
+  try {
+    const parsed = JSON.parse(readFileSync16(absolutePath, "utf-8"));
+    if (isRecord2(parsed)) current = parsed;
+  } catch {
+    current = {};
+  }
+  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."];
+  }
+  return [];
+}
 function sortResults(results, requests) {
   const order = new Map(requests.map((request, index) => [request.id, index]));
   return [...results].sort((a, b) => (order.get(a.id) ?? 0) - (order.get(b.id) ?? 0));
@@ -38533,7 +38874,7 @@ async function writeProcessLogs(roundDir, request, result) {
         phase: request.phase,
         model: request.model,
         prompt_path: request.promptPath,
-        status: "completed",
+        status: result.exitCode === 0 ? "completed" : "failed",
         started_at: startedAt,
         completed_at: completedAt,
         duration_ms: Math.max(0, Date.parse(completedAt) - Date.parse(startedAt)),
@@ -38697,7 +39038,7 @@ function newSessionId() {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   return `${date}-opencode-process-review-${Date.now()}`;
 }
-var runAgentsSubcommand = new Command("run-agents").description("Run OCR review through OpenCode process agents").argument("[target]", "Target path for fresh dashboard mode", ".").option("--session-id <workflow-session-id>", "Prepared workflow session id").option("--round <n>", "Prepared round number", (value) => Number.parseInt(value, 10)).option("--fresh", "Create a fresh workflow session before running process agents").option("--requirements <text-or-path>", "Inline requirements text or path to a requirements file").option("--team <json>", "JSON ReviewerInstance[] override for this run").option("--foreground", "Run in the current process instead of detaching a background worker").addOption(new Option("--worker", "Internal detached worker mode").hideHelp()).action(
+var runAgentsSubcommand = new Command("run-agents").description("Run OCR review through OpenCode process agents").argument("[target]", "Target path for fresh dashboard mode", ".").option("--session-id <workflow-session-id>", "Prepared workflow session id").option("--round <n>", "Prepared round number", (value) => Number.parseInt(value, 10)).option("--fresh", "Create a fresh workflow session before running process agents").option("--requirements <text-or-path>", "Inline requirements text or path to a requirements file").option("--team <json>", "JSON ReviewerInstance[] override for this run").option("--foreground", "Run in the current process instead of detaching a background worker").option("--background", "Detach and return immediately; not for normal OpenCode UI progress").addOption(new Option("--worker", "Internal detached worker mode").hideHelp()).action(
   async (target, options) => {
     const targetDir = process.cwd();
     requireOcrSetup(targetDir);
@@ -38726,7 +39067,7 @@ var runAgentsSubcommand = new Command("run-agents").description("Run OCR review
           throw new Error(
             [
               "run-agents requires either --fresh or --session-id.",
-              "Start a new process-agent review with: ocr review run-agents --fresh",
+              "Start a new OpenCode process-agent review with: ocr review run-agents --fresh",
               "Resume a prepared workflow round with: ocr review run-agents --session-id <id> --round <n>"
             ].join("\n")
           );
@@ -38755,6 +39096,10 @@ var runAgentsSubcommand = new Command("run-agents").description("Run OCR review
         console.log(`Progress: ocr review watch --session-id ${sessionId}`);
         console.log(`Status: ocr review status --session-id ${sessionId}`);
         console.log(`Artifacts: ${sessionDir}`);
+        if (options.background) {
+          console.log("Detached mode: this command is returning now. OpenCode UI will not show live progress unless the parent keeps polling status.");
+          return;
+        }
         console.log("Monitoring background review until it finishes. If OpenCode stops waiting, the background review continues.");
         const exitCode = await waitForDetachedRun(sessionDir, round);
         process.exit(exitCode);
@@ -38774,6 +39119,7 @@ var runAgentsSubcommand = new Command("run-agents").description("Run OCR review
         sessionDir,
         round,
         cwd: targetDir,
+        target,
         reviewers,
         pipelineAgents,
         requirements: readRequirements(options.requirements),
@@ -38916,13 +39262,16 @@ function renderReviewStatus(sessionDir, round) {
   if (runningReviewers.length > 0) {
     console.log(`Running reviewers: ${runningReviewers.map((meta) => meta.id).join(", ")}`);
   }
-  for (const phase of ["aggregation", "validation", "synthesis"]) {
+  for (const phase of ["aggregation", "validation", "synthesis", "translation-uk"]) {
     const meta = metas.find((item) => item.id === phase);
     console.log(`Pipeline ${phase}: ${String(meta?.status ?? "pending")}`);
   }
   if (existsSync23(join28(roundDir, "final.md"))) {
     console.log(source_default.green(`Final: ${join28(roundDir, "final.md")}`));
   }
+  if (existsSync23(join28(roundDir, "final.uk.md"))) {
+    console.log(source_default.green(`Final Ukrainian: ${join28(roundDir, "final.uk.md")}`));
+  }
 }
 function readdirMetaFiles(dir) {
   return existsSync23(dir) ? Array.from(new Set(readdirSync9(dir))).filter((name) => name.endsWith(".meta.json")).sort().map((name) => join28(dir, name)) : [];
@@ -39054,7 +39403,7 @@ function readDetachedSnapshot(sessionDir, round) {
     totalReviews: reviewers.length,
     runningReviews: reviewers.filter((meta) => meta.status === "running").map((meta) => String(meta.id)).sort(),
     pipeline: Object.fromEntries(
-      ["aggregation", "validation", "synthesis"].map((phase) => [
+      ["aggregation", "validation", "synthesis", "translation-uk"].map((phase) => [
         phase,
         String(metas.find((meta) => meta.id === phase)?.status ?? "pending")
       ])
@@ -39067,7 +39416,7 @@ function formatDetachedProgress(snapshot) {
     `OCR background status: ${snapshot.status}${snapshot.pid ? ` pid=${snapshot.pid} live=${snapshot.live ? "yes" : "no"}` : ""}`,
     `reviews ${snapshot.completedReviews}/${snapshot.totalReviews || "?"} complete`,
     `running: ${running}`,
-    `pipeline: aggregation=${snapshot.pipeline.aggregation}, validation=${snapshot.pipeline.validation}, synthesis=${snapshot.pipeline.synthesis}`
+    `pipeline: aggregation=${snapshot.pipeline.aggregation}, validation=${snapshot.pipeline.validation}, synthesis=${snapshot.pipeline.synthesis}, translation-uk=${snapshot.pipeline["translation-uk"]}`
   ].join(" | ");
 }
 var CONTROL_PROMPT = "Resume this OCR review: run `ocr state status --json` and act on `next_action`, continuing forward from `current_phase` without redoing completed phases.";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nk070281sjv/cli",
-  "version": "2.3.11",
+  "version": "2.3.17",
   "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.11",
+    "@nk070281sjv/agents": "2.3.17",
     "chalk": "^5.4.1",
     "chokidar": "^4.0.3",
     "commander": "^13.0.0",