md-zh-translation-skill 1.2.2 → 1.2.3

package/dist/src/internal/prompts/scheme-h.js

@@ -13,6 +13,7 @@ export const INITIAL_TRANSLATION_PROMPT = `
 2. 译文段落数必须与原文完全一致。每个英文段落对应一个中文段落，不得合并、拆分、重排。
 3. 只有以下内容第一次出现时才必须中英文对照，优先使用“中文（英文）”格式：人名、机构名、公司名、产品名、论文/期刊/会议名、专有项目名，以及对理解文章确实关键且中文读者未必熟悉的专业术语。这里的“关键专业术语”包括两类：一是明显的领域术语；二是虽然是常见科学名词，但在本文中反复出现、承载核心发现或后文持续围绕其展开的概念，例如某种材料、器官部位、结构名称、实验过程或关键机制。文章标题、各级标题、列表项中的首次出现也算首次出现。若某一列表或并列结构中首次出现多个州名、地区名、风暴名或术语，要逐项补齐，不要只给列表整体补一次。注意：中英文对照只针对这些局部元素本身，不要把整条标题、导语句、小标题或列表项原句整句附上英文；像 Earth、reptiles、paleontologist 这类通用名词、职业称谓、类群名或常见科学词，不要为了凑双语而强行加英文。
    如果上文上下文里已经给出“前文已完成首现锚定的专名/术语”清单，则清单内条目及其明显简称都视为已经在全文前文完成首现双语锚定；它们在当前分块标题、各级标题、列表项或正文里再次出现时，不要重复补首次中英文对照。
+   对没有成熟中文主译的产品名、系统名、工具名、命令名、框架名或操作系统名，如果需要建立首现锚定，可使用“英文原名（中文说明）”“中文说明（英文原名）”或其他自然的中英说明形式；严禁写成“Foo（Foo）”“Linux（Linux）”“Claude Code（Claude Code）”这种英文重复括注。
 4. 缩写第一次出现时，优先写成“中文全称（英文全称，缩写）”或最自然的中英文对照形式；若保留英文缩写并补中文解释，必须使用中文全角括号，例如“CNN（美国有线电视新闻网）”，不要写成“CNN (...)”。后文保持译法一致。
 5. 数字、年份、单位、比较关系、因果关系、条件关系必须准确，不得遗漏、增补或偷换。
 6. 如果原文使用英制数量和单位，请按以下规则处理：
@@ -63,6 +64,7 @@ export const GATE_AUDIT_PROMPT = `
 1. paragraph_match：段落数和段落顺序是否严格对应原文。
 2. first_mention_bilingual：人名、机构名、公司名、产品名、论文/期刊/会议名、专有项目名以及真正关键的专业术语第一次出现时是否完成中英文对照；标题、各级标题、列表项和正文中的第一次出现都要检查。这里的关键术语不仅包括明显的领域术语，也包括在本文中反复出现、承载核心发现或后文持续围绕其展开的科学名词。遇到州名、地区名、风暴名、并列术语或列表枚举时，要逐项检查。同时要判定对照范围是否过宽；如果把整条标题、导语句、小标题或列表项原句整句附上英文，或者给 Earth、reptiles、paleontologist 这类通用名词、职业称谓、类群名、常见科学词硬加英文，也应判为不通过。若同一核心概念存在多个英文变体，要检查是否在首次出现时就建立了稳定的双语对应，不能到后文某个变体出现时才第一次补英文。
    如果上文上下文里已经给出“前文已完成首现锚定的专名/术语”清单，则清单内条目及其明显简称一律视为已经在全文前文完成首现双语锚定；即使它们在当前分块标题、各级标题、列表项或正文里是本块第一次出现，也不得再按“首现缺少中英文对照”判错。
+   对没有成熟中文主译的产品名、系统名、工具名、命令名、框架名或操作系统名，如果译文写成“Foo（Foo）”这类英文重复括注，仍应判为不通过；这类情况必须改成带中文说明的自然中英锚定形式。
 3. numbers_units_logic：数字、年份、单位、比较关系、逻辑关系是否没有明显错漏。
 4. chinese_punctuation：是否符合中文标点习惯；如果保留完整英文段落，该英文段落内部可保留英文标点，不单独判错。中文句内若保留英文缩写并补中文解释，括号必须是全角，例如“CNN（美国有线电视新闻网）”。
 5. unit_conversion_boundary：长度、重量、华氏温度、以英寸表示的累计降水量是否按规则补常见换算，其他单位是否没有被擅自换算。
@@ -112,6 +114,7 @@ export const BUNDLED_GATE_AUDIT_PROMPT = `
 1. paragraph_match：该 segment 的段落数和段落顺序是否严格对应原文。
 2. first_mention_bilingual：该 segment 中的人名、机构名、公司名、产品名、论文/期刊/会议名、专有项目名以及真正关键的专业术语第一次出现时是否完成中英文对照；标题、各级标题、列表项和正文中的第一次出现都要检查。这里的关键术语不仅包括明显的领域术语，也包括在本文中反复出现、承载核心发现或后文持续围绕其展开的科学名词。遇到州名、地区名、风暴名、并列术语或列表枚举时，要逐项检查。同时要判定对照范围是否过宽；如果把整条标题、导语句、小标题或列表项原句整句附上英文，或者给 Earth、reptiles、paleontologist 这类通用名词、职业称谓、类群名、常见科学词硬加英文，也应判为不通过。若同一核心概念存在多个英文变体，要检查是否在首次出现时就建立了稳定的双语对应，不能到后文某个变体出现时才第一次补英文。
    如果上文上下文里已经给出“前文已完成首现锚定的专名/术语”清单，则清单内条目及其明显简称一律视为已经在全文前文完成首现双语锚定；即使它们在当前分块标题、各级标题、列表项或正文里是本块第一次出现，也不得再按“首现缺少中英文对照”判错。
+   对没有成熟中文主译的产品名、系统名、工具名、命令名、框架名或操作系统名，如果译文写成“Foo（Foo）”这类英文重复括注，仍应判为不通过；这类情况必须改成带中文说明的自然中英锚定形式。
 3. numbers_units_logic：数字、年份、单位、比较关系、逻辑关系是否没有明显错漏。
 4. chinese_punctuation：是否符合中文标点习惯；如果保留完整英文段落，该英文段落内部可保留英文标点，不单独判错。中文句内若保留英文缩写并补中文解释，括号必须是全角，例如“CNN（美国有线电视新闻网）”。
 5. unit_conversion_boundary：长度、重量、华氏温度、以英寸表示的累计降水量是否按规则补常见换算，其他单位是否没有被擅自换算。
@@ -143,6 +146,7 @@ export const REPAIR_PROMPT = `
 5. 没有列入 must_fix 的段落尽量不改；如果某段原本已经有正确的中英文对照、数字、单位换算或中文标点，修复时不得删除、改丢或简化。
 6. 对“首次出现中英文对照”问题，修复后的首次出现必须直接写成“中文（英文）”或等价的自然双语形式；标题、各级标题、列表项也适用，但只补局部专名或真正关键的专业术语，不得把整条标题、导语句、小标题或列表项原句整句附上英文，也不得给通用名词、职业称谓、类群名或常见科学词硬加英文。若某个科学名词在本文中反复出现、承载核心发现或后文持续围绕其展开，即使它本身是常见名词，也应按关键术语处理。若 must_fix 指出的是同一核心概念家族前后不一致，修复时要统一主译法和双语锚点。
    如果上文上下文里已经给出“前文已完成首现锚定的专名/术语”清单，则清单内条目及其明显简称都视为已经在全文前文完成首现双语锚定；修复时不要因为当前分块标题、各级标题、列表项或正文里再次出现这些条目，就重复补首现中英文对照。
+   对没有成熟中文主译的产品名、系统名、工具名、命令名、框架名或操作系统名，不要修成“Foo（Foo）”这类英文重复括注；应改成“英文原名（中文说明）”“中文说明（英文原名）”或其他自然的中英说明形式。
 7. 如果 must_fix 同时要求“保持原文名”和“补中文对照”，目标形式应是“中文（英文）”，不要只保留英文或只保留中文。
 8. 如果同一段里有多条 must_fix，允许一次性补齐，但修完后要保留这段原有的其他正确信息，不得因为补一个术语而删掉另一个已正确的对照或换算。
 9. 输出前按以下顺序自检：段落对应、首现中英对照、数字单位逻辑、中文标点、单位换算边界，确认 must_fix 中列出的每一项都已经修掉，并确认原本已正确的中英文对照和单位换算没有被修丢。

package/dist/src/markdown-protection.js

@@ -45,14 +45,8 @@ export function protectMarkdownSpans(body) {
     return { protectedBody, spans };
 }
 export function protectSegmentFormattingSpans(body, startIndex = 1) {
-    const spans = [];
-    const register = (kind, raw) => {
-        const id = createPlaceholder(kind, startIndex + spans.length);
-        spans.push({ id, kind, raw });
-        return id;
-    };
-    const protectedBody = mapOutsideInlineCode(body, (text) => protectInlineMarkdownLinks(text, register));
-    return { protectedBody, spans };
+    void startIndex;
+    return { protectedBody: body, spans: [] };
 }
 function protectFencedCodeBlocks(input, register) {
     const lines = input.split(/(?<=\n)/);

package/dist/src/translate.d.ts

@@ -13,6 +13,7 @@ export type TranslateOptions = {
     cwd?: string;
     sourcePathHint?: string;
     model?: string;
+    postDraftModel?: string;
     executor?: CodexExecutor;
     formatter?: typeof formatTranslatedBody;
     onProgress?: (message: string, stage: TranslateProgress) => void;

package/dist/src/translate.js

@@ -6,6 +6,7 @@ import { planMarkdownChunks } from "./markdown-chunks.js";
 import { extractFrontmatter, protectMarkdownSpans, protectSegmentFormattingSpans, reprotectMarkdownSpans, restoreMarkdownSpans } from "./markdown-protection.js";
 const DEFAULT_MODEL = "gpt-5.4-mini";
 const MAX_REPAIR_CYCLES = 2;
+const MAX_MUST_FIX_PER_REPAIR_CALL = 1;
 const DRAFT_REASONING_EFFORT = "medium";
 const AUDIT_REASONING_EFFORT = "medium";
 const REPAIR_REASONING_EFFORT = "low";
@@ -191,7 +192,11 @@ function report(options, stage, message) {
 export async function translateMarkdownArticle(source, options = {}) {
     const executor = options.executor ?? new DefaultCodexExecutor();
     const formatter = options.formatter ?? formatTranslatedBody;
-    const model = options.model ?? (process.env.TRANSLATION_MODEL?.trim() || DEFAULT_MODEL);
+    const draftModel = options.model ?? (process.env.TRANSLATION_MODEL?.trim() || DEFAULT_MODEL);
+    const postDraftModel = options.postDraftModel ?? (process.env.POST_DRAFT_MODEL?.trim() || draftModel);
+    const postDraftReasoningEffort = process.env.POST_DRAFT_REASONING_EFFORT?.trim()
+        ? process.env.POST_DRAFT_REASONING_EFFORT.trim()
+        : undefined;
     const cwd = options.cwd ?? process.cwd();
     const sourcePathHint = options.sourcePathHint ?? "article.md";
     const { frontmatter, body } = extractFrontmatter(source);
@@ -203,20 +208,26 @@ export async function translateMarkdownArticle(source, options = {}) {
     let repairCyclesUsed = 0;
     let styleApplied = false;
     let establishedTerms = [];
+    let nextLocalSpanIndex = spanIndex.size + 1;
     for (const chunk of chunkPlan.chunks) {
         const chunkResult = await translateProtectedChunk(chunk, chunkPlan, {
             cwd,
             executor,
-            model,
+            draftModel,
+            postDraftModel,
             options,
             sourcePathHint,
             spanIndex,
-            establishedTerms
+            establishedTerms,
+            nextLocalSpanIndex,
+            draftReasoningEffort: DRAFT_REASONING_EFFORT,
+            postDraftReasoningEffort
         });
         restoredChunks.push(chunkResult.body + chunk.separatorAfter);
         gateAudits.push(chunkResult.gateAudit);
         repairCyclesUsed += chunkResult.repairCyclesUsed;
         styleApplied = styleApplied || chunkResult.styleApplied;
+        nextLocalSpanIndex = chunkResult.nextLocalSpanIndex;
         establishedTerms = mergeEstablishedTerms(establishedTerms, collectEstablishedTerms(chunk.source, chunkResult.body));
     }
     report(options, "format", "Formatting translated Markdown.");
@@ -225,7 +236,7 @@ export async function translateMarkdownArticle(source, options = {}) {
         const markdown = reconstructMarkdown(frontmatter, formattedBody);
         return {
             markdown,
-            model,
+            model: draftModel,
             repairCyclesUsed,
             styleApplied,
             gateAudit: mergeGateAudits(gateAudits),
@@ -264,7 +275,7 @@ async function translateProtectedChunk(chunk, plan, context) {
     const draftedSegments = [];
     const fixedSegments = [];
     let repairCyclesUsed = 0;
-    let nextLocalSpanIndex = context.spanIndex.size + 1;
+    let nextLocalSpanIndex = context.nextLocalSpanIndex;
     for (const segment of segments) {
         if (segment.kind === "fixed") {
             fixedSegments.push(segment);
@@ -289,6 +300,7 @@ async function translateProtectedChunk(chunk, plan, context) {
         repairCyclesUsed += 1;
         const failedSegmentCount = bundledAudit.segments.filter((audit) => !isHardPass(audit)).length;
         report(context.options, "repair", `Chunk ${chunkPromptContext.chunkIndex}/${plan.chunks.length}${chunkLabel}: repair cycle ${repairCyclesUsed} of ${MAX_REPAIR_CYCLES} for ${failedSegmentCount} failed segment(s).`);
+        const repairedSegmentIndices = new Set();
         for (const segmentAudit of bundledAudit.segments) {
             if (isHardPass(segmentAudit) || segmentAudit.must_fix.length === 0) {
                 continue;
@@ -298,8 +310,9 @@ async function translateProtectedChunk(chunk, plan, context) {
                 throw new HardGateError(`Chunk ${chunkPromptContext.chunkIndex}/${plan.chunks.length}${chunkLabel}: unknown segment ${segmentAudit.segment_index} in bundled audit.`);
             }
             await repairDraftedSegment(draftedSegment, segmentAudit.must_fix, plan, context, chunkLabel);
+            repairedSegmentIndices.add(draftedSegment.segment.index + 1);
         }
-        bundledAudit = await runBundledGateAudit(draftedSegments, plan, context, chunkPromptContext, chunkLabel);
+        bundledAudit = await runPostRepairGateAudit(draftedSegments, bundledAudit, repairedSegmentIndices, plan, context, chunkPromptContext, chunkLabel);
     }
     if (!isBundledHardPass(bundledAudit)) {
         const remaining = bundledAudit.segments
@@ -324,13 +337,20 @@ async function translateProtectedChunk(chunk, plan, context) {
         report(context.options, "style", `Chunk ${chunkPromptContext.chunkIndex}/${plan.chunks.length}${chunkLabel}: applying style polish after hard gate pass.`);
         const styleResult = await context.executor.execute(withChunkContext(buildStylePolishPrompt(hardPassProtectedSource, hardPassProtectedChunk), chunkStylePromptContext), {
             cwd: context.cwd,
-            model: context.model,
-            reasoningEffort: STYLE_REASONING_EFFORT,
+            model: context.postDraftModel,
+            reasoningEffort: context.postDraftReasoningEffort ?? STYLE_REASONING_EFFORT,
             onStderr: (stderrChunk) => reportChunkProgress(context.options, "style", chunkPromptContext.chunkIndex - 1, plan, chunkLabel, stderrChunk)
         });
         try {
-            restoredChunkBody = restoreMarkdownSpans(styleResult.text, chunkSpans);
-            styleApplied = true;
+            const normalizedStyleText = stripAddedInlineCodeFromPlainPaths(hardPassProtectedSource, styleResult.text);
+            restoredChunkBody = restoreMarkdownSpans(normalizedStyleText, chunkSpans);
+            if (looksLikeMetaTaskResponse(restoredChunkBody)) {
+                report(context.options, "style", `Chunk ${chunkPromptContext.chunkIndex}/${plan.chunks.length}${chunkLabel}: style polish returned task-management or refusal text; falling back to the hard-pass translation.`);
+                restoredChunkBody = hardPassBody;
+            }
+            else {
+                styleApplied = true;
+            }
         }
         catch (error) {
             if (!(error instanceof HardGateError)) {
@@ -343,24 +363,74 @@ async function translateProtectedChunk(chunk, plan, context) {
         body: restoredChunkBody,
         repairCyclesUsed,
         styleApplied,
-        gateAudit: mergeGateAudits(bundledAudit.segments)
+        gateAudit: mergeGateAudits(bundledAudit.segments),
+        nextLocalSpanIndex
     };
 }
+function looksLikeMetaTaskResponse(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return false;
+    }
+    const patterns = [
+        /当前任务未提供.*issue/i,
+        /缺少\s*GitLab\s*项目与\s*issue\s*信息/i,
+        /缺少\s*GitLab\s*项目(?:信息)?/i,
+        /任务必须先绑定.*issue/i,
+        /按仓库内.*AGENTS\.md.*规则/i,
+        /请先提供.*issue/i,
+        /提供对应的项目链接和 issue 编号/i,
+        /请先提供.*项目链接/i,
+        /请提供对应项目链接/i,
+        /无法访问\s*GitLab/i,
+        /无法创建或访问项目/i,
+        /回复精确短语\s*`?NO_REPO`?/i,
+        /请明确回复\s*`?NO_REPO`?/i,
+        /未提供所属\s*GitLab\s*项目/i,
+        /Project override active/i
+    ];
+    return patterns.some((pattern) => pattern.test(trimmed));
+}
+function stripAddedInlineCodeFromPlainPaths(source, translated) {
+    const sourceInlineCodeTokens = new Set();
+    for (const match of source.matchAll(/`([^`\n]+)`/g)) {
+        const token = match[1]?.trim();
+        if (token) {
+            sourceInlineCodeTokens.add(token);
+        }
+    }
+    const sourceWithoutInlineCode = source.replace(/`[^`\n]+`/g, " ");
+    const plainPathTokens = new Set();
+    const pathPattern = /(^|[\s(（\[-])((?:~\/|\.{1,2}\/|\/(?!\/))[A-Za-z0-9._~/-]*[A-Za-z0-9_~/-])(?=$|[\s),，。；：！？\]）-])/gm;
+    for (const match of sourceWithoutInlineCode.matchAll(pathPattern)) {
+        const token = match[2]?.trim();
+        if (token && !sourceInlineCodeTokens.has(token)) {
+            plainPathTokens.add(token);
+        }
+    }
+    let normalized = translated;
+    for (const token of plainPathTokens) {
+        const escapedToken = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        normalized = normalized.replace(new RegExp("`" + escapedToken + "`", "g"), token);
+    }
+    return normalized;
+}
 async function translateProtectedSegment(segment, plan, context, chunkPromptContext, chunkLabel, localSpanStartIndex) {
     let threadId;
     const localFormatting = protectSegmentFormattingSpans(segment.source, localSpanStartIndex);
     const protectedSource = localFormatting.protectedBody;
     const combinedSpans = [...localFormatting.spans, ...segment.spans];
-    report(context.options, "draft", `Chunk ${chunkPromptContext.chunkIndex}/${plan.chunks.length}${chunkLabel}: starting translation with model ${context.model}.`);
+    report(context.options, "draft", `Chunk ${chunkPromptContext.chunkIndex}/${plan.chunks.length}${chunkLabel}: starting translation with model ${context.draftModel}.`);
     const draftResult = await context.executor.execute(withChunkContext(buildInitialPrompt(protectedSource), chunkPromptContext), {
         cwd: context.cwd,
-        model: context.model,
-        reasoningEffort: DRAFT_REASONING_EFFORT,
+        model: context.draftModel,
+        reasoningEffort: context.draftReasoningEffort,
         reuseSession: true,
         onStderr: (stderrChunk) => reportChunkProgress(context.options, "draft", chunkPromptContext.chunkIndex - 1, plan, chunkLabel, stderrChunk)
     });
     threadId = draftResult.threadId;
-    const canonicalProtectedBody = reprotectMarkdownSpans(draftResult.text, combinedSpans);
+    const normalizedDraftText = stripAddedInlineCodeFromPlainPaths(protectedSource, draftResult.text);
+    const canonicalProtectedBody = reprotectMarkdownSpans(normalizedDraftText, combinedSpans);
     const restoredBody = restoreMarkdownSpans(canonicalProtectedBody, combinedSpans);
     return {
         segment,
@@ -373,19 +443,176 @@ async function translateProtectedSegment(segment, plan, context, chunkPromptCont
     };
 }
 async function repairDraftedSegment(draftedSegment, mustFix, plan, context, chunkLabel) {
-    report(context.options, "repair", `Chunk ${draftedSegment.promptContext.chunkIndex}/${plan.chunks.length}${chunkLabel}, segment ${draftedSegment.segment.index + 1}: repairing failed segment.`);
-    const repairResult = await context.executor.execute(withChunkContext(buildRepairPrompt(draftedSegment.protectedSource, draftedSegment.protectedBody, mustFix), draftedSegment.promptContext), {
-        cwd: context.cwd,
-        model: context.model,
-        reasoningEffort: REPAIR_REASONING_EFFORT,
-        ...(draftedSegment.threadId ? { threadId: draftedSegment.threadId } : { reuseSession: true }),
-        onStderr: (stderrChunk) => reportChunkProgress(context.options, "repair", draftedSegment.promptContext.chunkIndex - 1, plan, `${chunkLabel}, segment ${draftedSegment.segment.index + 1}`, stderrChunk)
-    });
-    if (repairResult.threadId) {
-        draftedSegment.threadId = repairResult.threadId;
+    const mustFixBatches = splitMustFixBatches(mustFix, MAX_MUST_FIX_PER_REPAIR_CALL);
+    for (const [batchIndex, mustFixBatch] of mustFixBatches.entries()) {
+        const repairPromptContext = buildRepairPromptContext(draftedSegment.promptContext, mustFixBatch);
+        const batchSuffix = mustFixBatches.length > 1 ? `，修复批次 ${batchIndex + 1}/${mustFixBatches.length}` : "";
+        report(context.options, "repair", `Chunk ${draftedSegment.promptContext.chunkIndex}/${plan.chunks.length}${chunkLabel}, segment ${draftedSegment.segment.index + 1}: repairing failed segment${batchSuffix}.`);
+        const repairResult = await context.executor.execute(withChunkContext(buildRepairPrompt(draftedSegment.protectedSource, draftedSegment.protectedBody, mustFixBatch), repairPromptContext), {
+            cwd: context.cwd,
+            model: context.postDraftModel,
+            reasoningEffort: context.postDraftReasoningEffort ?? REPAIR_REASONING_EFFORT,
+            ...(draftedSegment.threadId ? { threadId: draftedSegment.threadId } : { reuseSession: true }),
+            onStderr: (stderrChunk) => reportChunkProgress(context.options, "repair", draftedSegment.promptContext.chunkIndex - 1, plan, `${chunkLabel}, segment ${draftedSegment.segment.index + 1}${batchSuffix}`, stderrChunk)
+        });
+        if (repairResult.threadId) {
+            draftedSegment.threadId = repairResult.threadId;
+        }
+        const normalizedRepairText = stripAddedInlineCodeFromPlainPaths(draftedSegment.protectedSource, repairResult.text);
+        draftedSegment.protectedBody = reprotectMarkdownSpans(normalizedRepairText, draftedSegment.spans);
+        draftedSegment.restoredBody = restoreMarkdownSpans(draftedSegment.protectedBody, draftedSegment.spans);
+    }
+}
+function splitMustFixBatches(mustFix, batchSize) {
+    const normalizedBatchSize = Math.max(1, batchSize);
+    const batches = [];
+    let index = 0;
+    while (index < mustFix.length) {
+        const batch = [mustFix[index]];
+        let batchTargets = extractExplicitEnglishTargetsFromMustFix(batch);
+        index += 1;
+        while (index < mustFix.length) {
+            const nextItem = mustFix[index];
+            const nextTargets = extractExplicitEnglishTargetsFromMustFix([nextItem]);
+            const withinBatchLimit = batch.length < normalizedBatchSize;
+            const relatedToBatch = batchTargets.length > 0 &&
+                nextTargets.length > 0 &&
+                nextTargets.some((candidate) => batchTargets.some((existing) => belongToSameConceptFamily(existing, candidate)));
+            if (!withinBatchLimit && !relatedToBatch) {
+                break;
+            }
+            batch.push(nextItem);
+            batchTargets = [...new Set([...batchTargets, ...nextTargets])];
+            index += 1;
+        }
+        batches.push(batch);
+    }
+    return batches;
+}
+function extractExplicitEnglishTargetsFromMustFix(mustFix) {
+    const targets = new Set();
+    for (const item of mustFix) {
+        for (const match of item.matchAll(/[“"`']([A-Za-z][A-Za-z0-9./+&:_ -]{0,79})[”"`']/g)) {
+            const candidate = match[1]?.trim();
+            if (!candidate) {
+                continue;
+            }
+            if (!/[A-Za-z]/.test(candidate)) {
+                continue;
+            }
+            targets.add(candidate);
+        }
+        for (const match of item.matchAll(/(?:核心术语|英文目标|英文词|英文原名|产品名|工具名|项目名|模型名|CLI 名称|命令名|框架名|平台名|机制名|概念)\s+([A-Za-z][A-Za-z0-9./+&:_ -]{0,79}?)(?=\s*(?:首次|首现|在|需|应|未|缺少|没有|作为|并|，|。|；|：|$))/g)) {
+            const candidate = match[1]?.trim();
+            if (!candidate) {
+                continue;
+            }
+            if (!/[A-Za-z]/.test(candidate)) {
+                continue;
+            }
+            targets.add(candidate);
+        }
+    }
+    return [...targets];
+}
+function extractConceptFamilyTargets(targets) {
+    const normalized = [...new Set(targets.map((item) => item.trim()).filter(Boolean))];
+    const families = [];
+    const seen = new Set();
+    for (const base of normalized) {
+        if (seen.has(base)) {
+            continue;
+        }
+        const related = normalized.filter((candidate) => {
+            if (candidate === base) {
+                return true;
+            }
+            return belongToSameConceptFamily(base, candidate);
+        });
+        if (related.length < 2) {
+            continue;
+        }
+        related.forEach((item) => seen.add(item));
+        families.push(related);
+    }
+    return families;
+}
+function belongToSameConceptFamily(left, right) {
+    const normalizedLeft = left.trim().toLowerCase();
+    const normalizedRight = right.trim().toLowerCase();
+    if (!normalizedLeft || !normalizedRight) {
+        return false;
+    }
+    return (normalizedLeft === normalizedRight ||
+        normalizedLeft.startsWith(normalizedRight + " ") ||
+        normalizedRight.startsWith(normalizedLeft + " "));
+}
+function buildRepairPromptContext(promptContext, mustFix) {
+    const extraNotes = [...promptContext.specialNotes];
+    const explicitEnglishTargets = extractExplicitEnglishTargetsFromMustFix(mustFix);
+    const conceptFamilyTargets = extractConceptFamilyTargets(explicitEnglishTargets);
+    const targetsHeadingLikeAnchor = mustFix.some((item) => item.includes("标题") || item.includes("首次出现") || item.includes("中英对照"));
+    if (promptContext.segmentHeadings.length > 0 &&
+        promptContext.specialNotes.some((item) => item.includes("当前分段包含标题或加粗标题")) &&
+        targetsHeadingLikeAnchor) {
+        extraNotes.push(`本次 must_fix 明确指向标题。必须直接修改以下标题文本本身：${promptContext.segmentHeadings.join(" | ")}。`, "不要把标题里的首现双语修复转移到正文其他句子；标题缺什么，就在标题里补什么。", "如果标题里的目标是英文产品名、工具名、项目名、模型名、CLI 名称，或以英文表达的核心概念性标题术语，而常见中文主译并不稳定，修复时优先保留英文原名，并在标题本身补最小必要的中文说明或类属锚定；不要只把标题其他部分翻成中文，却让这个英文专名或核心概念继续裸露未锚定。");
+        if (promptContext.segmentHeadings.some((heading) => /[/／]/.test(heading))) {
+            extraNotes.push("如果标题里有用 / 连接的并列平台名、系统名、工具名或范围限定语，修复时必须在标题本身完整保留这组并列结构，不要删掉任何一侧，也不要把其中一侧挪到正文。", "这类并列标签若需要补首现双语，应在标题里为整组并列范围补自然的中文说明或锚定，不要只补其中一个英文项，也不要把说明转移到标题后面的段落。", "对 `A/B` 这类并列英文标签，优先保留整组英文原名，再在整组后面补一个整体中文说明词，例如“平台”“系统”“工具”或等价表达；不要把它改成英文重复括注，也不要拆成两处分别补。");
+        }
+        if (promptContext.specialNotes.some((item) => item.includes("当前分段包含列表前的说明句"))) {
+            extraNotes.push("如果当前分段的结构是“冒号引导句或说明句 + 下一行加粗标题/标题 + 后续列表”，而 must_fix 指向的是该标题中的首现双语缺失，必须直接在这个标题本身补齐锚定；不要把修复转移到前面的引导句，也不要只在后面的列表项里补一次。", "对这类结构里的核心概念性英文标题，例如分类名、能力名、隔离/限制/保护等机制名称，修复目标应是标题本身的最小自然双语形式，例如“中文标题（English Term）”或等价表达；不要只保留中文标题。");
+        }
+    }
+    if (promptContext.specialNotes.some((item) => item.includes("当前分段包含列表项")) &&
+        mustFix.some((item) => item.includes("条目") || item.includes("项目符号") || item.includes("列表项"))) {
+        extraNotes.push("本次 must_fix 明确指向列表项或项目符号。必须直接修改对应的列表项文本本身，不要把缺失的首现双语转移到列表前后的说明段落里。", "如果 must_fix 指向多个列表项，要逐条在各自的列表项里补齐；不要只在列表标题、段首总结句或其他项目符号里补一次。", "如果 must_fix 点名的是某个列表项里的核心英文概念、术语或英文短语，就必须在该列表项本身保留这个英文原名并补自然中文锚定；不要只保留同一列表项括号里的另一个英文专名、品牌名、缩写或解释来冒充“已修复”。", "对“概念名（解释）”“中文概念（英文原名）”或带括号说明的列表项，修复时要分清主锚定对象和括号说明：被 must_fix 点名的核心概念必须在这一条列表项里直接补齐，不能因为括号里还有别的英文词就省略它。");
+    }
+    if (promptContext.specialNotes.some((item) => item.includes("当前分段包含列表前的说明句")) &&
+        mustFix.some((item) => item.includes("中文说明") || item.includes("英文缩写") || item.includes("首次出现"))) {
+        extraNotes.push("本次 must_fix 明确指向列表前的说明句、导语句或冒号引导句。必须直接修改对应引导句本身，不要把缺失的首现双语或中文说明转移到后面的列表项里。", "如果 must_fix 指向引导句中的英文缩写、包名、命令名、产品名或术语，优先在同一句里补自然的中文说明，并保持这一句仍然是后续列表的引导句。");
+    }
+    if (mustFix.some((item) => item.includes("当前句") || item.includes("该句")) &&
+        mustFix.some((item) => item.includes("首次出现") || item.includes("中英对照") || item.includes("中文说明"))) {
+        extraNotes.push("本次 must_fix 明确指向当前句或该句的正文说明。必须直接在这同一句本身补齐缺失的首现中英文对照或中文说明，不要把修复转移到同一分段的前一句、后一句、标题、列表项或总结句里。", "如果目标术语、缩写、包名、命令名、产品名或概念出现在这句正文里，应在保持原句论证关系和语气的前提下就地补自然的中文锚定，不要只修同段别处。");
+    }
+    if (mustFix.some((item) => /第\d+段/.test(item)) &&
+        mustFix.some((item) => item.includes("首次出现") || item.includes("中英文") || item.includes("中英对照"))) {
+        extraNotes.push("本次 must_fix 明确点名了某一具体段落。必须直接在被点名的那一段本身补齐缺失的首现中英文对照或中文说明，不要把锚定转移到同分段的其他段、标题、引用外说明、列表项或后续小节里。", "如果 must_fix 已经写明“第N段”或直接摘录了该段原句，修复时应把该段视为唯一有效落点：被点名的英文术语、产品名、概念名或机制名，必须在这段对应中文词处就地补齐英文原名或中文说明。");
+    }
+    if (promptContext.specialNotes.some((item) => item.includes("当前分段包含引用段落")) &&
+        mustFix.some((item) => item.includes("引用段")) &&
+        mustFix.some((item) => item.includes("首次出现") || item.includes("中英文") || item.includes("中英对照"))) {
+        extraNotes.push("本次 must_fix 明确指向引用段中的句子。必须直接在对应引用句本身补齐缺失的首现中英文对照或中文说明，不要把锚定转移到引用外的标题、正文、列表项或后续小节里。", "如果 must_fix 点名了引用段中的英文术语、机制名、产品名或概念，例如 Sandbox、Prompt injection、Supply chain attacks 等，修复时必须在该引用句里的对应中文词处就地补齐英文原名；不要把英文锚点延后到后文标题或下一段第一次出现的位置。");
     }
-    draftedSegment.protectedBody = reprotectMarkdownSpans(repairResult.text, draftedSegment.spans);
-    draftedSegment.restoredBody = restoreMarkdownSpans(draftedSegment.protectedBody, draftedSegment.spans);
+    if (explicitEnglishTargets.length > 0) {
+        extraNotes.push(`本次 must_fix 明确点名了这些英文目标：${explicitEnglishTargets.join(" / ")}。`, "只要 must_fix 已经点名某个英文词、命令名、语言名、包名、平台名或术语，即使它看起来是常见技术词，也必须严格按 must_fix 要求修复，不能因为“太常见”就省略首现锚定。", "修复时必须在对应的标题、当前句、列表项或被点名位置本身保留这个英文原名，并补最小必要的中文说明；不要只译成中文，也不要把锚定转移到别处。");
+    }
+    if (conceptFamilyTargets.length > 0) {
+        extraNotes.push(`本次 must_fix 里存在同一概念家族的多个英文目标：${conceptFamilyTargets
+            .map((family) => family.join(" / "))
+            .join(" ; ")}。`, "对同一概念家族里的 base term 和 extended term，必须把它们视为两个独立锚点分别修复；不能因为已经补了较短词组，就省略较长词组，反之亦然。", "如果 must_fix 同时点名了引用句里的短概念和说明句/引导句里的扩展概念，修复时要在各自被点名的位置分别补齐，不要把其中一个锚点挪去充当另一个。");
+    }
+    if (mustFix.some((item) => item.includes("重复回括") ||
+        item.includes("重复括注") ||
+        item.includes("重复回注") ||
+        item.includes("重复同一英文"))) {
+        extraNotes.push("本次 must_fix 明确指出英文原名出现了重复回括或重复括注。修复时同一个英文原名在同一个首现锚点里只能保留一次，不要再生成“中文说明（同一英文原名）”或等价的重复回括格式。", "如果要为英文原名补中文说明，优先使用自然的单次锚定形式，例如“English（中文说明）”“English + 中文说明”或其他只保留一次英文原名的写法；不要把同一个英文词先写进正文，又在括号里重复一次。");
+    }
+    if (mustFix.some((item) => item.includes("双层括号") ||
+        item.includes("嵌套格式") ||
+        item.includes("单层括注") ||
+        item.includes("不嵌套"))) {
+        extraNotes.push("本次 must_fix 明确指出当前写法出现了双层括号或嵌套括注。修复时如果原句、列表项或标题里本来就已经有一层括注说明，必须在这一层括注内部完成中英锚定，不要再额外套第二层括号。", "对这类已有括注的首现锚定，优先改成单层括注里的并列说明，例如“（中文说明，English）”“（English，中文说明）”或等价的单层形式；不要生成“（中文（English））”或任何双层括号格式。");
+    }
+    if (mustFix.some((item) => item.includes("inline code") ||
+        item.includes("反引号") ||
+        item.includes("Markdown 结构"))) {
+        extraNotes.push("本次 must_fix 明确指出当前译文擅自把原文普通文本改成了 inline code。修复时如果原文中的路径、目录名、文件名、URL 片段或命令样式文本本来没有反引号，就必须保持普通文本结构，不要新增反引号或把它们包成 inline code。", "对列表项里的 `~/.ssh/`、`~/.aws/`、`~/.config/` 这类路径，如果原文只是普通列表文本加括注说明，修复时应继续保持普通列表文本，只调整双语说明或中文解释；不要把路径本身改成代码样式。");
+    }
+    return {
+        ...promptContext,
+        specialNotes: extraNotes
+    };
 }
 async function runBundledGateAudit(draftedSegments, plan, context, chunkPromptContext, chunkLabel) {
     const segmentIndices = draftedSegments.map((segment) => segment.segment.index + 1);
@@ -396,8 +623,8 @@ async function runBundledGateAudit(draftedSegments, plan, context, chunkPromptCo
     const prompt = withChunkContextAt(buildBundledGateAuditPrompt(formatBundledAuditSegments(draftedSegments)), chunkPromptContext, "【分段审校输入】");
     const auditResult = await context.executor.execute(prompt, {
         cwd: context.cwd,
-        model: context.model,
-        reasoningEffort: AUDIT_REASONING_EFFORT,
+        model: context.postDraftModel,
+        reasoningEffort: context.postDraftReasoningEffort ?? AUDIT_REASONING_EFFORT,
         outputSchema: BUNDLED_GATE_AUDIT_SCHEMA,
         reuseSession: true,
         onStderr: (stderrChunk) => reportChunkProgress(context.options, "audit", chunkPromptContext.chunkIndex - 1, plan, chunkLabel, stderrChunk)
@@ -419,6 +646,18 @@ async function runBundledGateAudit(draftedSegments, plan, context, chunkPromptCo
     }
     return bundledAudit;
 }
+async function runPostRepairGateAudit(draftedSegments, previousAudit, repairedSegmentIndices, plan, context, chunkPromptContext, chunkLabel) {
+    report(context.options, "audit", `Chunk ${chunkPromptContext.chunkIndex}/${plan.chunks.length}${chunkLabel}: re-running per-segment hard gate audit after repair.`);
+    const repairedSegments = draftedSegments.filter((segment) => repairedSegmentIndices.has(segment.segment.index + 1));
+    if (repairedSegments.length === 0) {
+        return previousAudit;
+    }
+    const updatedAudit = await runFallbackSegmentAudits(repairedSegments, plan, context, chunkPromptContext, chunkLabel);
+    const updatedByIndex = new Map(updatedAudit.segments.map((segmentAudit) => [segmentAudit.segment_index, segmentAudit]));
+    return {
+        segments: previousAudit.segments.map((segmentAudit) => updatedByIndex.get(segmentAudit.segment_index) ?? segmentAudit)
+    };
+}
 async function runFallbackSegmentAudits(draftedSegments, plan, context, chunkPromptContext, chunkLabel) {
     const segments = [];
     for (const draftedSegment of draftedSegments) {
@@ -427,8 +666,8 @@ async function runFallbackSegmentAudits(draftedSegments, plan, context, chunkPro
             : chunkLabel;
         const auditResult = await context.executor.execute(withChunkContext(buildGateAuditPrompt(draftedSegment.protectedSource, draftedSegment.protectedBody), draftedSegment.promptContext), {
             cwd: context.cwd,
-            model: context.model,
-            reasoningEffort: AUDIT_REASONING_EFFORT,
+            model: context.postDraftModel,
+            reasoningEffort: context.postDraftReasoningEffort ?? AUDIT_REASONING_EFFORT,
             outputSchema: GATE_AUDIT_SCHEMA,
             reuseSession: true,
             onStderr: (stderrChunk) => reportChunkProgress(context.options, "audit", chunkPromptContext.chunkIndex - 1, plan, segmentLabel, stderrChunk)
@@ -572,7 +811,7 @@ function isHeadingLikeBlock(content) {
     if (/^#{1,6}[ \t]+.+$/.test(trimmed)) {
         return true;
     }
-    return /^\*\*[^*\n].+\*\*$/.test(trimmed);
+    return /^\*\*[^*\n].+\*\*$/.test(trimmed) || /^\*\*[^*\n]+\*\*\s*(?:—|-|:).+$/.test(trimmed);
 }
 function splitRawBlocks(source) {
     if (source.length === 0) {
@@ -606,15 +845,27 @@ function measureRawBlocks(blocks) {
 }
 function collectChunkSpans(source, spanIndex, extraSpans = []) {
     const placeholderPattern = /@@MDZH_[A-Z_]+_\d{4,}@@/g;
-    const spanIds = [...new Set(source.match(placeholderPattern) ?? [])];
     const localSpanIndex = new Map(extraSpans.map((span) => [span.id, span]));
-    return spanIds.map((spanId) => {
+    const collected = [];
+    const seen = new Set();
+    const addSpan = (spanId) => {
+        if (seen.has(spanId)) {
+            return;
+        }
         const span = localSpanIndex.get(spanId) ?? spanIndex.get(spanId);
         if (!span) {
             throw new HardGateError(`Protected span integrity failed: unknown placeholder ${spanId}.`);
         }
-        return span;
-    });
+        seen.add(spanId);
+        collected.push(span);
+        for (const nestedSpanId of span.raw.match(placeholderPattern) ?? []) {
+            addSpan(nestedSpanId);
+        }
+    };
+    for (const spanId of [...new Set(source.match(placeholderPattern) ?? [])]) {
+        addSpan(spanId);
+    }
+    return collected;
 }
 function extractSegmentHeadingHints(source) {
     const hints = [];
@@ -631,18 +882,35 @@ function extractSegmentHeadingHints(source) {
         const boldMatch = trimmed.match(/^\*\*(.+)\*\*$/);
         if (boldMatch?.[1]) {
             hints.push(boldMatch[1].trim());
+            continue;
+        }
+        const boldLeadMatch = trimmed.match(/^\*\*([^*\n]+)\*\*\s*(?:—|-|:)\s*(.+)$/);
+        if (boldLeadMatch?.[1]) {
+            hints.push(boldLeadMatch[1].trim());
         }
     }
     return hints;
 }
 function extractSegmentSpecialNotes(source) {
     const notes = [];
+    if (containsHeadingLikeBlock(source)) {
+        notes.push("当前分段包含标题或加粗标题。若标题中的关键术语、产品名、项目名或专业概念是全文首次出现，必须直接在标题本身补齐中英文对照；不要把这类修复转移到正文其他句子里。", "修复标题首现双语时，只补局部术语或专名本身，不要把整条标题原句附上英文，也不要只润色中文标题却遗漏必须补齐的英文锚点。");
+    }
     if (containsAttributionLikeBlock(source)) {
         notes.push("当前分段包含图注、署名、来源、配图说明或出品归属类文本。对这类归属说明里的公司名、机构名、品牌名、作者名或媒体名，如果原文本身以英文原名、署名格式或 credit/byline 形式呈现，不要为了满足首现双语而强行创造中文主译。", "这类归属说明优先保留原文归属格式，可做最小必要的中文化，但不要把 `Anthropic（Anthropic）` 这类同文重复括注当作正确修复目标，也不要因为缺少中文主译就判为必须修复。");
     }
     if (containsToolNameExplanationBlock(source)) {
         notes.push("当前分段包含工具名、命令名、包名、CLI 名称或产品名的列表项说明。对这类以英文原名作为标签的说明条目，允许保留英文原名，并在后面直接接中文解释；不要为了满足首现双语而强行改写成“中文（英文）”主译格式。", "对于 `kubectl - Kubernetes cluster access`、`docker - ...`、`npm install -g ...` 这类工具/命令/产品说明，只要英文原名保留且中文解释清楚，就可视为合格的首现锚定；不要把“英文名（中文解释）”误判为必须修复。");
     }
+    if (containsListLikeBlock(source)) {
+        notes.push("当前分段包含列表项或项目符号。若列表项中的术语、产品名、命令名或其他关键专名需要补首现双语，必须直接在对应列表项本身补齐，不要把修复转移到列表前后的正文说明里。", "如果同一列表里有多个条目各自首次出现不同术语，要逐条补齐，不要只在列表标题、总结句或某一个项目符号里补一次。");
+    }
+    if (containsListLeadInBlock(source)) {
+        notes.push("当前分段包含列表前的说明句、导语句或冒号引导句。若这类引导句本身首次出现术语、缩写、产品名、包名、命令名或其他关键专名，必须直接在该说明句本身补齐中英文对照或中文说明，不要把修复转移到后面的列表项里。", "这类引导句通常以冒号结束，用来引出后续列表。修复时应保留原有引导结构，只在该句内部补最小必要的首现锚定，不要改写成列表项标题，也不要把解释拆到下一行列表中。");
+    }
+    if (containsBlockquoteBlock(source)) {
+        notes.push("当前分段包含引用段落或 `>` 引用句。若引用段中的术语、产品名、机制名或其他关键专名需要补首现中英文对照，必须直接在对应引用句本身补齐，不要把修复转移到引用前后的正文、标题或后续小节里。", "修复引用句时，应保留引用结构和原句判断关系，只在引用句内部补最小必要的英文锚点或中文说明；不要把被点名的英文术语延后到后文标题、列表项或总结句。");
+    }
     if (containsTranslatableMarkdownStructure(source)) {
         notes.push("当前分段包含可翻译的 Markdown 强调结构或命令/flag 写法。翻译时必须保留等价结构：原文中的 **加粗**、*斜体* 等强调，不得无故去掉；像 --dangerously-skip-permissions 这类命令参数或 flag，应保留原始写法，不要改成代码块、标题、列表标签或其他 Markdown 结构。", "如果强调结构里的正文需要翻译，请翻译内容本身，但保留强调标记；如果命令、flag、配置键名或 CLI 参数本身是英文原名，请保留原名，只翻译周围解释。");
     }
@@ -651,6 +919,9 @@ function extractSegmentSpecialNotes(source) {
 function containsAttributionLikeBlock(source) {
     return splitRawBlocks(source).some((block) => isAttributionLikeBlock(block.content));
 }
+function containsHeadingLikeBlock(source) {
+    return splitRawBlocks(source).some((block) => isHeadingLikeBlock(block.content));
+}
 function isAttributionLikeBlock(content) {
     const trimmed = content.trim();
     if (trimmed.length === 0 || trimmed.includes("\n")) {
@@ -665,9 +936,43 @@ function isAttributionLikeBlock(content) {
 function containsToolNameExplanationBlock(source) {
     return splitRawBlocks(source).some((block) => isToolNameExplanationBlock(block.content));
 }
+function containsListLikeBlock(source) {
+    return splitRawBlocks(source).some((block) => isListLikeBlock(block.content));
+}
+function containsListLeadInBlock(source) {
+    const blocks = splitRawBlocks(source);
+    for (let index = 0; index < blocks.length - 1; index += 1) {
+        const current = blocks[index]?.content.trim() ?? "";
+        const next = blocks[index + 1]?.content ?? "";
+        const nextNext = blocks[index + 2]?.content ?? "";
+        if (current.length === 0 ||
+            isHeadingLikeBlock(current) ||
+            isListLikeBlock(current) ||
+            !/[:：]\s*$/.test(current)) {
+            continue;
+        }
+        if (isListLikeBlock(next)) {
+            return true;
+        }
+        if (isHeadingLikeBlock(next) && isListLikeBlock(nextNext)) {
+            return true;
+        }
+    }
+    return false;
+}
+function containsBlockquoteBlock(source) {
+    return splitRawBlocks(source).some((block) => block.content
+        .split(/\r?\n/)
+        .some((line) => line.trimStart().startsWith(">")));
+}
 function isToolNameExplanationBlock(content) {
     return content.split(/\r?\n/).some((line) => isToolNameExplanationLine(line));
 }
+function isListLikeBlock(content) {
+    return content
+        .split(/\r?\n/)
+        .some((line) => /^(\s*)([-*+]|\d+\.)\s+/.test(line.trimStart()));
+}
 function isToolNameExplanationLine(line) {
     const trimmed = line.trim();
     if (!trimmed.startsWith("- ")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "md-zh-translation-skill",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "CLI skill for translating English Markdown articles into polished Chinese Markdown with a hidden gated pipeline.",
   "type": "module",
   "bin": {