dowafu 0.1.0 → 0.3.1

package/dist/output.js

@@ -1,13 +1,16 @@
 // plan_dispatch_v1.4.md §12/§16：落檔與 run.jsonl。寫入序列化——前一次 appendFile 未
 // resolve 前不發下一次；呼叫平行，寫入序列。所有落檔內容在寫入前經 maskDeep 遮蔽（§12）。
-import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { maskDeep, maskString } from "./mask.js";
+import { m } from "./messages.js";
 export class RunLogWriter {
     filePath;
+    lang;
     queue = Promise.resolve();
-    constructor(filePath) {
+    constructor(filePath, lang) {
         this.filePath = filePath;
+        this.lang = lang;
     }
     // plan_dispatch_v2.4.md §12（一）：ts 語意為「append 被呼叫的當下」，即事件發生時刻，
     // 故在此（方法本體）取時間，不得延後到 queue 的 then callback 內——落盤時間會被檔案
@@ -21,7 +24,7 @@ export class RunLogWriter {
         // append 都不會執行，且 flush() 也會 rejected，等於一次瞬時寫入失敗讓該次派工
         // 其餘所有事件全部遺失。失敗以 stderr 留痕，不靜默吞掉。
         this.queue = this.queue.then(() => appendFile(this.filePath, line, "utf8")).catch((err) => {
-            console.error(`run.jsonl 寫入失敗：${maskString(String(err))}`);
+            console.error(m(this.lang, "runLogWriteFailed", maskString(String(err))));
         });
     }
     async flush() {
@@ -37,6 +40,20 @@ export async function ensureOutDir(outDir) {
     // （issue_log_v2.0.md 2026-08-07：hub 驗收時據此數錯 9／22 vs 實際 7／20）。
     await writeFile(path.join(outDir, "run.jsonl"), "", "utf8");
 }
+// 上面 §13 那條「重跑會覆蓋同名輸出目錄」的前提是**重跑的人知道自己在覆蓋什麼**。
+// 四格 host 對測（2026-08-13）打掉了那個前提：hub 會在派工前自己 rm -rf 掉輸出目錄，
+// 沒有人被問過，而那底下是已經付過錢的產物。覆蓋本身不改（此處語意維持不變），改成
+// 由 cli.ts 在**還沒呼叫任何 API 的地方**擋下來——目錄非空就中止，並要求換 ticket-id。
+// 讀不到目錄（不存在、或權限不足）一律回 false：不存在本來就該放行，權限不足則交給
+// 後面的 ensureOutDir 報 outDirNotWritable，兩者的訊息各自比這裡準確。
+export async function outDirHasArtifacts(outDir) {
+    try {
+        return (await readdir(outDir)).length > 0;
+    }
+    catch {
+        return false;
+    }
+}
 // §13：raw 一律無條件覆寫。v2.4 實作期間曾加過「空 raw 不覆蓋磁碟上的非空內容」守衛
 // （由 v2.4 §20 的一條測試要求逼出來），驗收時撤除：它破壞了 §13「同一工單重跑會覆蓋
 // 同名輸出目錄」——重跑時該 spoke 若零 raw，上一次的內容會留著冒充本次證據，與
@@ -53,22 +70,25 @@ export async function writeRawFiles(outDir, agent, result) {
 }
 // §13：「原文產出」欄——failed 無產出；其餘（含 truncated:*）皆落檔，即使不完整，
 // 因為那是已經付過錢的內容。
-export async function writeSpokeText(outDir, agent, result) {
+export async function writeSpokeText(outDir, agent, result, lang) {
     if (result.status === "failed")
         return;
-    const content = result.finalText ?? `(無法取得完整回報，執行狀態：${result.status})`;
+    // issue_log_v2.5.md 待修 #7：本函式一度是唯一沒有遮蔽的落檔路徑——`raw/` 與 `run.jsonl`
+    // 都經 maskDeep，只有這裡直寫 finalText。spoke 讀的是被審專案的原始碼，那裡若有硬編金鑰，
+    // 它可以照抄進「原文」欄（§16 模板要求逐字複製），於是秘密落到一個不經遮蔽的檔案裡。
+    const content = maskString(result.finalText ?? m(lang, "noFullReportAvailable", result.status));
     await writeFile(path.join(outDir, `${agent}.md`), content, "utf8");
 }
 // plan_dispatch_v2.4.md §13（一）：每支 spoke 完成即落檔的落地點。落檔例外不得外傳——
 // 落檔失敗不得使呼叫端的 promise rejected、不得改變該 spoke 的 status（落檔是產物持久化，
 // 不是執行結果），但必須留下痕跡：寫入 result.errors[] 並經 onError 回報。
 // writeSpokeText、writeRawFiles 各自包住例外，其一失敗不影響另一個執行。
-export async function persistSpokeResult(outDir, result, onError) {
+export async function persistSpokeResult(outDir, result, onError, lang) {
     try {
-        await writeSpokeText(outDir, result.agent, result);
+        await writeSpokeText(outDir, result.agent, result, lang);
     }
     catch (err) {
-        const msg = `落檔失敗（${result.agent}.md）：${maskString(String(err))}`;
+        const msg = m(lang, "persistTextFailed", result.agent, maskString(String(err)));
         result.errors.push(msg);
         onError(msg);
     }
@@ -76,7 +96,7 @@ export async function persistSpokeResult(outDir, result, onError) {
         await writeRawFiles(outDir, result.agent, result);
     }
     catch (err) {
-        const msg = `落檔失敗（${result.agent} raw/）：${maskString(String(err))}`;
+        const msg = m(lang, "persistRawFailed", result.agent, maskString(String(err)));
         result.errors.push(msg);
         onError(msg);
     }
@@ -84,35 +104,40 @@ export async function persistSpokeResult(outDir, result, onError) {
 function formatStoreCell(store) {
     return store === "false" ? "false" : store;
 }
-const BUDGET_TRIGGER_LABEL = {
-    total: "總量",
-    reasoning: "推理累積",
-    reasoning_round: "推理單輪尖峰",
-};
 // §14：truncated:budget 需顯示觸發來源；reasoning_round 是「模型在某一輪卡住」的異常訊號，
 // 與正常的總量／累積推理超支後續動作不同（前者查 prompt 或換 effort，後者調門檻），
 // 須顯眼區分，不能跟其他 truncated:budget 混在一起看起來像同一種情況。
-function formatStatusCell(r) {
+function formatStatusCell(r, lang) {
     if (r.status !== "truncated:budget" || !r.budgetTrigger)
         return r.status;
-    const label = BUDGET_TRIGGER_LABEL[r.budgetTrigger];
-    const flag = r.budgetTrigger === "reasoning_round" ? "⚠ 異常尖峰・" : "";
+    const label = m(lang, "budgetTriggerLabel", r.budgetTrigger);
+    const flag = r.budgetTrigger === "reasoning_round" ? m(lang, "anomalySpikeFlag") : "";
     return `${r.status}（${flag}${label}）`;
 }
 // plan_dispatch_v2.0.md §15（二）：清單外引用附出現章節與疑似縮寫來源，讓讀者不必自己去猜
 // （issue_log_v2.0.md 2026-08-07：曾有 hub 因為裸字串誤判成稽核器的 bug，推錯了方向）。
-function formatOutsideAllowlistCell(detail) {
+function formatOutsideAllowlistCell(detail, lang) {
     if (detail.length === 0)
-        return "無";
+        return m(lang, "noneLabel");
     return detail
         .map((d) => {
-        const sectionPart = d.section ? `「${d.section}」節` : "章節外";
-        const suffixPart = d.suffixOf ? `；疑似 ${d.suffixOf} 的縮寫` : "";
-        return `${d.path}（${sectionPart}${suffixPart}）`;
+        const sectionPart = d.section ? m(lang, "outsideAllowlistSection", d.section) : m(lang, "outsideAllowlistNoSection");
+        const suffixPart = d.suffixOf ? m(lang, "outsideAllowlistSuffixNote", d.suffixOf) : "";
+        return m(lang, "outsideAllowlistEntry", d.path, `${sectionPart}${suffixPart}`);
     })
         .join(",");
 }
-export function buildSummaryMarkdown(ticketId, results, audits, toolCallAudits) {
+// plan_i18n_v1.2.md §4.1：SUSPECT_PHRASES 中英兩套並存比對，summary.md 分開標示是哪一套
+// 命中——日後調整這份清單時才有資料可依據，不必再猜一次。
+function formatSuspectPhrasesDetail(a, lang) {
+    const parts = [];
+    if (a.suspectPhrasesZh.length > 0)
+        parts.push(`zh:${a.suspectPhrasesZh.join(",")}`);
+    if (a.suspectPhrasesEn.length > 0)
+        parts.push(`en:${a.suspectPhrasesEn.join(",")}`);
+    return parts.length > 0 ? parts.join(" / ") : m(lang, "noneLabel");
+}
+export function buildSummaryMarkdown(ticketId, results, audits, toolCallAudits, lang) {
     const rows = results.map((r) => {
         const a = audits.get(r.agent);
         const t = toolCallAudits.get(r.agent);
@@ -120,33 +145,31 @@ export function buildSummaryMarkdown(ticketId, results, audits, toolCallAudits)
         // plan_dispatch_v2.6.md §26 規格四：hub 會讀的地方才有用（「順序放大量」印進乾跑報表
         // 後 hub 才真的重排清單，第 10 次派工，省 52%），放最前面顯眼標示。
         if (r.unknownUsageKeys.length > 0) {
-            cells.push(`⚠ 未知 usage 欄位：${r.provider} ${r.unknownUsageKeys.join(", ")}`);
+            cells.push(m(lang, "unknownUsageKeysWarning", r.provider, r.unknownUsageKeys.join(", ")));
         }
         // §15（一）：沒看程式碼就作答的簽名，放最前面顯眼標示——見 tool-call-audit.ts。
         if (t?.zeroSourceRead) {
-            cells.push(`⚠ 零原始碼讀取（允許 ${t.allowedReadsCount} 檔）`);
+            cells.push(m(lang, "zeroSourceReadWarning", t.allowedReadsCount));
         }
         if (t) {
-            cells.push(`工具呼叫:${t.total}（允許 ${t.allowed}／拒絕 ${t.rejected}）`);
+            cells.push(m(lang, "toolCallStats", t.total, t.allowed, t.rejected));
         }
         if (a) {
-            cells.push(`收尾句:${a.finalLinePass ? "pass" : "fail"}`, `觀察:${a.observationCount ?? "無法計數"}`, // v1.9 §15：null（數不出來）與 0（明確為零）須可區分，不得混印
-            `清單外引用:${formatOutsideAllowlistCell(a.citedPathsOutsideAllowlistDetail)}`, `無法驗證欄:${a.cannotVerifySectionPresent ? "pass" : "fail"}`, `疑似禁止內容:${a.suspectPhrases.length > 0 ? a.suspectPhrases.join(",") : "無"}`);
+            cells.push(m(lang, "closingLineCell", a.finalLinePass ? "pass" : "fail"), 
+            // v1.9 §15：null（數不出來）與 0（明確為零）須可區分，不得混印
+            m(lang, "observationCountCell", a.observationCount !== null ? String(a.observationCount) : m(lang, "cannotCountObservations")), m(lang, "outsideAllowlistCell", formatOutsideAllowlistCell(a.citedPathsOutsideAllowlistDetail, lang)), m(lang, "cannotVerifySectionCell", a.cannotVerifySectionPresent ? "pass" : "fail"), m(lang, "suspectPhrasesCell", formatSuspectPhrasesDetail(a, lang)));
         }
-        const auditCell = cells.length > 0 ? cells.join(" / ") : "(無法稽核)";
+        const auditCell = cells.length > 0 ? cells.join(" / ") : m(lang, "auditUnavailable");
         // plan_fixes_v1.0.md §4：無價目資料須與「估出來是 $0」區分，不能印成空白或 0——
         // 兩者對讀者的意義完全不同（沒資料 vs 免費）。
-        const costCell = r.costUsd === null ? "無價目資料" : `$${r.costUsd.toFixed(4)}`;
-        return `| ${r.agent} | ${r.provider} | ${r.api} | ${r.modelRequested} | ${r.modelReturned ?? "—"} | ${r.effort ?? "—"} | ${formatStoreCell(r.store)} | ${formatStatusCell(r)} | ${r.latencyMs}ms | ${r.usage.totalTokens} | ${costCell} | ${auditCell} |`;
+        const costCell = r.costUsd === null ? m(lang, "noPricingData") : `$${r.costUsd.toFixed(4)}`;
+        return `| ${r.agent} | ${r.provider} | ${r.api} | ${r.modelRequested} | ${r.modelReturned ?? "—"} | ${r.effort ?? "—"} | ${formatStoreCell(r.store)} | ${formatStatusCell(r, lang)} | ${r.latencyMs}ms | ${r.usage.totalTokens} | ${costCell} | ${auditCell} |`;
     });
-    return `# dispatch summary — ${ticketId}
-
-| agent | provider | api | model(請求) | model(回傳) | effort | store | status | 耗時 | token | 估算成本 | 稽核 |
-| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+    return `${m(lang, "summaryHeader", ticketId)}
 ${rows.join("\n")}
 `;
 }
-export async function writeSummary(outDir, ticketId, results, audits, toolCallAudits) {
-    const md = buildSummaryMarkdown(ticketId, results, audits, toolCallAudits);
+export async function writeSummary(outDir, ticketId, results, audits, toolCallAudits, lang) {
+    const md = buildSummaryMarkdown(ticketId, results, audits, toolCallAudits, lang);
     await writeFile(path.join(outDir, "summary.md"), md, "utf8");
 }

package/dist/prompt.js

@@ -39,7 +39,9 @@ const TOOL_NOTE_EN = "You have one tool, `read_file(path)`. Neither the ticket n
 // plan_dispatch_v2.1.md §8（二）：組裝順序改為 agent body → 工具說明 → 回報模板。原順序
 // （agent body → 回報模板 → 工具說明）讓工具說明掉在回報模板的固定收尾句之後，在結構上
 // 像附註——而那正是唯一說明「你有工具」的段落（provider log system-1.txt 全文證實）。
-export function buildSystemPrompt(agentBody, lang = "zh") {
+// plan_i18n_v1.3.md §一之2：不設預設值——不是安全網（九個既有呼叫端都已顯式傳值，
+// 一個都不會紅），是防未來新增的呼叫端靜默拿到與產品預設（en）相反的值。
+export function buildSystemPrompt(agentBody, lang) {
     const toolNote = lang === "en" ? TOOL_NOTE_EN : TOOL_NOTE;
     const template = lang === "en" ? REPORT_TEMPLATE_EN : REPORT_TEMPLATE;
     return [agentBody.trim(), toolNote, template].join("\n\n");
@@ -76,7 +78,7 @@ function displayTicketDir(ticketDir, repoRoot) {
         return ticketDir;
     return rel;
 }
-export function buildFirstUserText(ticketDir, agent, allowedReadsRelative, repoRoot, lang = "zh") {
+export function buildFirstUserText(ticketDir, agent, allowedReadsRelative, repoRoot, lang) {
     const dir = displayTicketDir(ticketDir, repoRoot);
     if (lang === "en") {
         return `Do these in order:
@@ -98,7 +100,7 @@ ${buildStep3(allowedReadsRelative, lang)}
 「允許讀取」清單內的路徑相對於 repo 根目錄，不是相對於工單目錄。
 清單外的檔案會被拒絕。被拒時不要重試，在「無法驗證」欄記下缺什麼。`;
 }
-export function buildFinalizeUserText(lang = "zh") {
+export function buildFinalizeUserText(lang) {
     return lang === "en"
         ? "You have reached the execution limit. Produce your report now from what you already have; do not call any more tools."
         : "已達執行上限，請依現有資訊直接產出目前的回報，不要再呼叫工具。";

package/dist/providers.js

@@ -1,15 +1,16 @@
 // plan_dispatch_v1.4.md §5：providers.json 載入與驗證。fail closed——api 欄缺失或
 // store:true 即中止（exit 2），不套用預設值繼續跑（§10 步驟 3）。
 import { readFile } from "node:fs/promises";
-import { DispatchError } from "./types.js";
-function parseReasoning(raw, providerName) {
+import { DispatchError, } from "./types.js";
+import { m } from "./messages.js";
+function parseReasoning(raw, providerName, lang) {
     if (!raw || typeof raw !== "object") {
         return { style: null, allowed: [] };
     }
     const r = raw;
     const style = r.style;
     if (style !== undefined && style !== "openai" && style !== "deepseek" && style !== "gemini" && style !== "anthropic") {
-        throw new DispatchError(`providers.json: ${providerName}.reasoning.style 值不合法："${String(style)}"`, 2);
+        throw new DispatchError(m(lang, "reasoningStyleInvalid", providerName, String(style)), 2);
     }
     const allowed = Array.isArray(r.allowed) ? r.allowed.filter((v) => typeof v === "string") : [];
     const modelOverrides = r.modelOverrides && typeof r.modelOverrides === "object"
@@ -21,75 +22,86 @@ function parseReasoning(raw, providerName) {
     let def;
     if (r.default !== undefined) {
         if (typeof r.default !== "string") {
-            throw new DispatchError(`providers.json: ${providerName}.reasoning.default 須為字串`, 2);
+            throw new DispatchError(m(lang, "reasoningDefaultNotString", providerName), 2);
         }
         def = r.default;
     }
     if (allowed.length > 0 && def === undefined) {
-        throw new DispatchError(`providers.json: ${providerName}.reasoning.default 缺失——allowed 非空時必填，不得回退到「不送參數」`, 2);
+        throw new DispatchError(m(lang, "reasoningDefaultMissing", providerName), 2);
     }
     if (def !== undefined && !allowed.includes(def)) {
-        throw new DispatchError(`providers.json: ${providerName}.reasoning.default "${def}" 不在 allowed 內（${allowed.length > 0 ? allowed.join(", ") : "（空）"}）`, 2);
+        const list = allowed.length > 0 ? allowed.join(", ") : m(lang, "emptyList");
+        throw new DispatchError(m(lang, "reasoningDefaultNotAllowed", providerName, def, list), 2);
     }
     return { style: style ?? null, allowed, default: def, modelOverrides };
 }
 // plan_fixes_v1.0.md §4：pricing 為選填——缺席的 provider／模型無法估算成本（cost.ts
 // 回傳 null，不是 0），不強制每個 provider 都要有價目。有填就驗完整，格式錯即中止
 // （fail closed，與本檔其餘欄位一致），不悄悄忽略壞掉的價目導致成本估算安靜地錯。
-function parsePositiveNumber(v, label) {
+function parsePositiveNumber(v, label, lang) {
     if (typeof v !== "number" || !(v > 0)) {
-        throw new DispatchError(`providers.json: ${label} 須為正數，實際為 ${JSON.stringify(v)}`, 2);
+        throw new DispatchError(m(lang, "positiveNumberRequired", label, JSON.stringify(v)), 2);
     }
     return v;
 }
-function parsePricing(raw, providerName) {
+function parsePricing(raw, providerName, lang) {
     if (raw === undefined)
         return undefined;
     if (!raw || typeof raw !== "object") {
-        throw new DispatchError(`providers.json: ${providerName}.pricing 不是物件`, 2);
+        throw new DispatchError(m(lang, "pricingNotObject", providerName), 2);
     }
     const out = {};
     for (const [model, entry] of Object.entries(raw)) {
         if (!entry || typeof entry !== "object") {
-            throw new DispatchError(`providers.json: ${providerName}.pricing.${model} 不是物件`, 2);
+            throw new DispatchError(m(lang, "pricingModelNotObject", providerName, model), 2);
         }
         const e = entry;
         out[model] = {
-            inputPerM: parsePositiveNumber(e.inputPerM, `${providerName}.pricing.${model}.inputPerM`),
-            outputPerM: parsePositiveNumber(e.outputPerM, `${providerName}.pricing.${model}.outputPerM`),
+            inputPerM: parsePositiveNumber(e.inputPerM, `${providerName}.pricing.${model}.inputPerM`, lang),
+            outputPerM: parsePositiveNumber(e.outputPerM, `${providerName}.pricing.${model}.outputPerM`, lang),
             ...(e.cachedInputPerM !== undefined
-                ? { cachedInputPerM: parsePositiveNumber(e.cachedInputPerM, `${providerName}.pricing.${model}.cachedInputPerM`) }
+                ? { cachedInputPerM: parsePositiveNumber(e.cachedInputPerM, `${providerName}.pricing.${model}.cachedInputPerM`, lang) }
                 : {}),
             ...(e.cacheWritePerM !== undefined
-                ? { cacheWritePerM: parsePositiveNumber(e.cacheWritePerM, `${providerName}.pricing.${model}.cacheWritePerM`) }
+                ? { cacheWritePerM: parsePositiveNumber(e.cacheWritePerM, `${providerName}.pricing.${model}.cacheWritePerM`, lang) }
                 : {}),
         };
     }
     return out;
 }
-function parseProviderConfig(name, raw) {
+// v0.2.0：只取 `pricingSource.asOf`，而且**刻意寬鬆**——與上面的 `parsePricing` 相反。
+// 理由是兩者性質不同：`pricing` 是計費輸入，錯了成本會安靜地算錯，所以 fail closed；
+// `asOf` 只是報表上的一個查證日期，壞掉的後果是「少印一個日期」。對它 fail closed 會讓
+// 一份價目完全正確的 `--providers` 檔，因為 metadata 打錯字而整個跑不起來。
+function parsePricingAsOf(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const asOf = raw.asOf;
+    return typeof asOf === "string" && asOf.trim().length > 0 ? asOf.trim() : undefined;
+}
+function parseProviderConfig(name, raw, lang) {
     if (!raw || typeof raw !== "object") {
-        throw new DispatchError(`providers.json: provider "${name}" 的設定不是物件`, 2);
+        throw new DispatchError(m(lang, "providerConfigNotObject", name), 2);
     }
     const r = raw;
     // §5：api 欄無預設值，介面選擇不容猜測——缺失即中止。
     if (r.api !== "responses" && r.api !== "gemini-native" && r.api !== "anthropic-messages") {
-        throw new DispatchError(`providers.json: ${name}.api 缺失或不合法（須為 "responses"、"gemini-native" 或 "anthropic-messages"），實際為 ${JSON.stringify(r.api)}`, 2);
+        throw new DispatchError(m(lang, "providerApiInvalid", name, JSON.stringify(r.api)), 2);
     }
     // §5：store 不可為 true——違反設計原則 6（零留存）即中止。
     if (r.store === true) {
-        throw new DispatchError(`providers.json: ${name}.store 為 true，違反設計原則 6（零留存）。載入即中止，不得依賴伺服器端狀態。`, 2);
+        throw new DispatchError(m(lang, "providerStoreTrue", name), 2);
     }
     const store = r.store === null ? null : false; // 未填視為 false
     if (typeof r.baseURL !== "string" || r.baseURL.length === 0) {
-        throw new DispatchError(`providers.json: ${name}.baseURL 缺失`, 2);
+        throw new DispatchError(m(lang, "providerBaseUrlMissing", name), 2);
     }
     // §5：models 白名單。未填（或非陣列）視為空陣列 = 不做型號檢查。
     const models = Array.isArray(r.models) ? r.models.filter((v) => typeof v === "string") : [];
     // §5：charsPerToken。未填時用 CLI 全域值——保留 null，不在此處套 1.0（CLI 端才知道
     // 使用者傳入的 --chars-per-token 是多少）。
     if (r.charsPerToken !== undefined && (typeof r.charsPerToken !== "number" || !(r.charsPerToken > 0))) {
-        throw new DispatchError(`providers.json: ${name}.charsPerToken 須為正數`, 2);
+        throw new DispatchError(m(lang, "providerCharsPerTokenInvalid", name), 2);
     }
     const charsPerToken = typeof r.charsPerToken === "number" ? r.charsPerToken : null;
     return {
@@ -97,12 +109,13 @@ function parseProviderConfig(name, raw) {
         api: r.api,
         store,
         toolCalling: r.toolCalling === true,
-        reasoning: parseReasoning(r.reasoning, name),
+        reasoning: parseReasoning(r.reasoning, name, lang),
         models,
         charsPerToken,
         tpmLimit: typeof r.tpmLimit === "number" ? r.tpmLimit : null,
         maxSpokeTokens: typeof r.maxSpokeTokens === "number" ? r.maxSpokeTokens : null,
-        pricing: parsePricing(r.pricing, name),
+        pricing: parsePricing(r.pricing, name, lang),
+        pricingAsOf: parsePricingAsOf(r.pricingSource),
     };
 }
 // plan_dispatch_v1.10.md §24.3：providers.json 隨工具出貨，不可覆寫（方案 D）。
@@ -110,42 +123,41 @@ function parseProviderConfig(name, raw) {
 // 在載入時做，不符即中止，防跨版本漂移（一份舊版 providers.json 寫著已證實不生效的
 // 參數路徑，可能回顯、不報錯，行為完全不受控，facts_dispatch.md 2026-08-06 已有實例）。
 export const PROVIDERS_FORMAT_VERSION = 1;
-export function parseProvidersFile(json) {
+export function parseProvidersFile(json, lang) {
     if (!json || typeof json !== "object") {
-        throw new DispatchError("providers.json 格式不是物件", 2);
+        throw new DispatchError(m(lang, "providersFileNotObject"), 2);
     }
     const { formatVersion, ...providerEntries } = json;
     if (formatVersion !== PROVIDERS_FORMAT_VERSION) {
-        throw new DispatchError(`providers.json: formatVersion 不符（預期 ${PROVIDERS_FORMAT_VERSION}，實際 ${JSON.stringify(formatVersion)}）。` +
-            `這通常代表 --providers 指向了舊版或不相容的檔案。`, 2);
+        throw new DispatchError(m(lang, "providersFormatVersionMismatch", PROVIDERS_FORMAT_VERSION, JSON.stringify(formatVersion)), 2);
     }
     const out = {};
     for (const [name, raw] of Object.entries(providerEntries)) {
-        out[name] = parseProviderConfig(name, raw);
+        out[name] = parseProviderConfig(name, raw, lang);
     }
     return out;
 }
-export async function loadProviders(filePath) {
+export async function loadProviders(filePath, lang) {
     let text;
     try {
         text = await readFile(filePath, "utf8");
     }
     catch {
-        throw new DispatchError(`找不到 providers.json：${filePath}`, 2);
+        throw new DispatchError(m(lang, "missingProviders", filePath), 2);
     }
     let json;
     try {
         json = JSON.parse(text);
     }
     catch (err) {
-        throw new DispatchError(`providers.json 不是合法 JSON：${err.message}`, 2);
+        throw new DispatchError(m(lang, "providersFileInvalidJson", err.message), 2);
     }
-    return parseProvidersFile(json);
+    return parseProvidersFile(json, lang);
 }
-export function getProviderConfig(providers, name) {
+export function getProviderConfig(providers, name, lang) {
     const config = providers[name];
     if (!config) {
-        throw new DispatchError(`providers.json 未定義 provider "${name}"`, 2);
+        throw new DispatchError(m(lang, "providerUndefined", name), 2);
     }
     return config;
 }

package/dist/raw-integrity.js

@@ -17,33 +17,34 @@
 // 物件被傳過去」，而非「長得像的東西存在」，後者會掩蓋掉真正的 bug（例如重新建構出一個
 // 內容相似但簽章欄位被序列化過程改寫的複製品）。若未來 adapter 需要對 raw 做任何正規化，
 // 這個判準本身就需要重新設計——那是規格問題，不是這裡的實作可以自行決定的。
+import { m } from "./messages.js";
 export class RawIntegrityError extends Error {
     constructor(message) {
         super(message);
         this.name = "RawIntegrityError";
     }
 }
-export function checkRawArrayIntegrity(conv, builtInput) {
+export function checkRawArrayIntegrity(conv, builtInput, lang) {
     for (const turn of conv.turns) {
         if (turn.role !== "assistant")
             continue;
         if (!Array.isArray(turn.raw)) {
-            throw new RawIntegrityError("raw 完整性檢查失敗：assistant turn 的 raw 不是陣列（responses adapter 預期 raw 為上一輪 response.output 陣列）");
+            throw new RawIntegrityError(m(lang, "rawIntegrityNotArray"));
         }
         for (const item of turn.raw) {
             if (!builtInput.includes(item)) {
                 const type = item?.type ?? "?";
-                throw new RawIntegrityError(`raw 完整性檢查失敗：assistant turn 有一個 item（type=${type}）未以原樣出現在送出的請求中，疑似續接時被過濾掉`);
+                throw new RawIntegrityError(m(lang, "rawIntegrityItemNotFound", type));
             }
         }
     }
 }
-export function checkRawObjectIntegrity(conv, builtContents) {
+export function checkRawObjectIntegrity(conv, builtContents, lang) {
     for (const turn of conv.turns) {
         if (turn.role !== "assistant")
             continue;
         if (!builtContents.includes(turn.raw)) {
-            throw new RawIntegrityError("raw 完整性檢查失敗：assistant turn 的 raw 未以原樣出現在送出的 contents 中，疑似續接時被重建或漏帶");
+            throw new RawIntegrityError(m(lang, "rawIntegrityObjectNotFound"));
         }
     }
 }

package/dist/report.js

@@ -1,16 +1,19 @@
 // plan_dispatch_v1.4.md §11：派工報表（呼叫前）。模型錯了、effort 不如預期、介面走錯、
 // 成本量級不對，在送出前就看得到。不使用 ✓／✗ 標記——TPM 是滑動窗，429 等待會動態改變
 // 實際並行數，靜態估算無法精確預測。
+import { stripFrontmatter } from "./ticket.js";
+import { FIXED_CLOSING_LINE, FIXED_CLOSING_LINE_EN } from "./audit.js";
+import { m } from "./messages.js";
 export function effectiveCap(spoke, cli) {
     return spoke.providerConfig.maxSpokeTokens ?? cli.maxSpokeTokens;
 }
 export function effectiveCharsPerToken(spoke, cli) {
     return spoke.providerConfig.charsPerToken ?? cli.charsPerToken;
 }
-function formatProvidersSource(src) {
+function formatProvidersSource(src, lang) {
     if (src.kind === "bundled")
-        return `出貨（formatVersion ${src.formatVersion}）`;
-    return `外部檔 ${src.path}（formatVersion ${src.formatVersion}）`;
+        return m(lang, "providersBundled", src.formatVersion);
+    return m(lang, "providersExplicit", src.path ?? "", src.formatVersion);
 }
 // v1.10 §10：三態不得合併——「未忽略」是需要處理的狀態，「無法判定」不是，措辭須區分。
 //
@@ -18,22 +21,64 @@ function formatProvidersSource(src) {
 // 已訂輸出目錄屬呼叫端 cwd，checkGitignore 檢查的也是 cwd 所屬的 repo——cwd 與
 // --repo-root 指的目標專案是兩回事（v1.11 §10 修的正是這個基準不一致）。「目標專案」
 // 這個詞在 cwd ≠ repoRoot 時會指錯對象，故改為不預設兩者相同的措辭。
-function formatGitignoreWarning(status, outDir) {
+function formatGitignoreWarning(status, outDir, lang) {
     if (status === "ignored")
         return null;
     if (status === "not_ignored") {
-        return `  ⚠ 輸出目錄 ${outDir} 未被輸出目錄所在的 git repo 忽略`;
+        return m(lang, "gitignoreNotIgnored", outDir);
     }
-    return `  ℹ 無法判定輸出目錄 ${outDir} 是否被 .gitignore 涵蓋（非 git repo 或 git 不可用）`;
+    return m(lang, "gitignoreUnknown", outDir);
 }
-export function buildReport(ticketId, spokes, estimates, allowlistEstimates, cli, outDir, meta) {
+// plan_i18n_v1.2.md §6.3：呼叫前提示 lens 收尾句落在哪一個 FIXED_CLOSING_LINE*——只提示不擋
+// （同既有 gitignore 警告），讓 lens 檔案本身的收尾句指示（如「回報最後一行固定為：...」）
+// 在真正付費呼叫之前先被人看到有沒有漂移。agentBody 已在 resolveSpokes 剝過 frontmatter，
+// 這裡再跑一次 stripFrontmatter 是冪等的（不再以 --- 開頭，regex 不命中），不需重讀檔。
+function lensClosingLineStatus(agentBody) {
+    const lines = stripFrontmatter(agentBody).split(/\r?\n/).map((l) => l.trim());
+    const lastNonEmpty = [...lines].reverse().find((l) => l.length > 0) ?? "";
+    if (lastNonEmpty.includes(FIXED_CLOSING_LINE))
+        return "zh";
+    if (lastNonEmpty.includes(FIXED_CLOSING_LINE_EN))
+        return "en";
+    return "none";
+}
+// 沒有收尾句的 lens（如 explore-haiku.md，不是 hole-finder 系列、不受這份收尾句約定拘束）
+// 回傳 null、不印任何提示——只對「有收尾句、值得比對」的 lens 發聲，才不會對每一支
+// 不相干的 lens 都噴一行「未偵測到」的常駐噪音。
+function formatLensClosingLineNotice(spoke, lang) {
+    const status = lensClosingLineStatus(spoke.agentBody);
+    if (status === "zh")
+        return m(lang, "lensClosingLineZh", spoke.agent);
+    if (status === "en")
+        return m(lang, "lensClosingLineEn", spoke.agent);
+    return null;
+}
+// v0.2.0：把本次型號的單價印進乾跑報表。起因是 /publish-check 判斷清單第 4 項
+// （「指向的機制在外部專案存在嗎」）：skill 改成「價目查 providers.json，不要查官網」之後，
+// 外部專案的 hub 其實找不到那個檔——它隨套件出貨，躺在 node_modules 或全域安裝目錄底下，
+// 路徑帶版本號與相依雜湊，猜不到。找不到就會退回舊行為去查官網，等於那條規則只修了一半。
+//
+// **這一行讓那個檔不必被找到。** 順帶也解決 `--providers` 覆寫之後 hub 讀到錯的那一份。
+// 缺價目時明講「無價目資料」而不是印 0——與 cost.ts 的 null 語意一致（§4：「無法估算」
+// 與「估算出來是零」不是同一件事）。
+function formatModelPricing(spoke, lang) {
+    const pricing = spoke.providerConfig.pricing?.[spoke.model];
+    if (!pricing)
+        return m(lang, "modelPricingMissing", spoke.model);
+    const cached = pricing.cachedInputPerM !== undefined ? m(lang, "modelPricingCachedSuffix", pricing.cachedInputPerM) : "";
+    const asOf = spoke.providerConfig.pricingAsOf
+        ? m(lang, "modelPricingAsOfSuffix", spoke.providerConfig.pricingAsOf)
+        : "";
+    return m(lang, "modelPricing", pricing.inputPerM, pricing.outputPerM, cached, asOf);
+}
+export function buildReport(ticketId, spokes, estimates, allowlistEstimates, cli, outDir, meta, lang) {
     const estByAgent = new Map(estimates.map((e) => [e.agent, e.estimatedTokens]));
-    const lines = [`即將派工 ${ticketId}：`];
+    const lines = [m(lang, "aboutToDispatch", ticketId)];
     // v1.10 §11：repoRoot 明列於報表，與 store 同性質的可見性保證——白名單是整套隔離的
     // 唯一支點（§7），其邊界由「從哪個目錄下指令」決定，這件事在報表上必須看得見，否則
     // 使用者無從發現自己在錯的目錄下跑。
     lines.push(`  repoRoot   ${meta.repoRoot}`);
-    lines.push(`  providers  ${formatProvidersSource(meta.providersSource)}`);
+    lines.push(`  providers  ${formatProvidersSource(meta.providersSource, lang)}`);
     for (const spoke of spokes) {
         const est = estByAgent.get(spoke.agent) ?? 0;
         const cap = effectiveCap(spoke, cli);
@@ -41,6 +86,10 @@ export function buildReport(ticketId, spokes, estimates, allowlistEstimates, cli
             `[${spoke.providerConfig.api}] effort=${spoke.effort ?? "—"} lang=${spoke.lang} ` +
             `store=${spoke.providerConfig.store === false ? "false" : "n/a"} ` +
             `est. ${est.toLocaleString()}  cap ${cap.toLocaleString()}`);
+        lines.push(`  ${formatModelPricing(spoke, lang)}`);
+        const closingLineNotice = formatLensClosingLineNotice(spoke, lang);
+        if (closingLineNotice)
+            lines.push(`  ${closingLineNotice}`);
     }
     const totalEst = estimates.reduce((s, e) => s + e.estimatedTokens, 0);
     const worstTotal = spokes.reduce((s, spoke) => s + effectiveCap(spoke, cli), 0);
@@ -48,37 +97,42 @@ export function buildReport(ticketId, spokes, estimates, allowlistEstimates, cli
     // 這個數字只涵蓋 system prompt ＋ buildFirstUserText() 產出的第一則訊息，不含工單與
     // 允許清單本身（那些是 spoke 自己用 tool call 讀進去的）。實測差距 27 倍（2,593 vs
     // 71,482）。標籤明講範圍，並緊接印出允許清單總量，讓兩個數字一起出現、不必自己去找。
-    lines.push(`  初始 prompt 估算 ${totalEst.toLocaleString()} tokens（僅 system prompt＋首則訊息，不含工單與允許清單；本閘門的估算上限 ${cli.maxTokens.toLocaleString()}）`);
+    lines.push(m(lang, "initialPromptEstimate", totalEst.toLocaleString(), cli.maxTokens.toLocaleString()));
     // §14：獨立於閘門一之外，只呈現不設閘門——閘門一不含允許清單與工單內容（issue_log_v2.0.md
     // 2026-08-07），此數字才是「若整個允許清單都被讀完」的量級參考，門檻待樣本累積後再定。
     const totalAllowlistTokens = allowlistEstimates.reduce((s, e) => s + e.estimatedTokens, 0);
     const totalAllowlistFiles = allowlistEstimates.reduce((s, e) => s + e.fileCount, 0);
-    lines.push(`  允許清單總量估算 ${totalAllowlistTokens.toLocaleString()} tokens（${totalAllowlistFiles} 檔）`);
+    lines.push(m(lang, "allowlistTotalEstimate", totalAllowlistTokens.toLocaleString(), totalAllowlistFiles));
     // plan_dispatch_v2.4.md §14：口徑說明——避免此數字被誤讀為預期消耗。三件事：
     // (1) 字元數的上限估計，不是預期消耗；(2) 不去重，同一檔出現在多支清單會重複計入
     // （正確行為：兩支各讀一次就是兩份成本）；(3) 實測程式碼素材約 3.5 字元／token，
     // 故實際消耗通常遠低於此數（charsPerToken 假設 1.0，係數本身刻意不動，見 §14）。
-    lines.push(`    └ 上限估計，不去重；實測程式碼素材約 3.5 字元／token，實際消耗通常遠低於此數`);
+    lines.push(m(lang, "allowlistEstimateCaveat"));
     // issue_log_v2.1.md（第 8、9 次）：多數模型一輪只叫一個檔，每輪重送全部歷史，故清單靠前
     // 的檔會被重複計費多次。這一行是「順序造成的放大量」，也是唯一 hub 改得動的成本槓桿——
     // 只印排序能省的部分，不印預估總量：總量還受「批次讀 vs 逐個讀」影響（模型決定，我們
     // 控制不了），印出來會被當成預期值。省下的百分比則不受 charsPerToken 偏差影響（分子分母
     // 抵銷），是這裡唯一可信的絕對數字。
+    //
+    // real-run-same-lens §九之6 要求這一行標明「此為逐個讀假設下的上限」，訊息文字已補。
+    // real-run-i18n-lang（2026-08-12）另加一條：讀檔形態**不只隨型號變，也隨 prompt 語言變**
+    // ——同型號同 effort，只把語言從中文換成英文，luna 的 feasibility 就從 9 輪（逐個）
+    // 變 4 輪（批次）。所以「這個廠牌會不會批次」在乾跑階段更不可能預先判定。
     const seqAsListed = allowlistEstimates.reduce((s, e) => s + e.sequential.asListed, 0);
     const seqSorted = allowlistEstimates.reduce((s, e) => s + e.sequential.sorted, 0);
     if (seqAsListed > 0) {
         const savedPct = Math.round(((seqAsListed - seqSorted) / seqAsListed) * 100);
-        lines.push(`  逐個讀的順序放大量 ${seqAsListed.toLocaleString()} tokens（清單內容被重送的總量）`);
+        lines.push(m(lang, "sequentialReadAmplification", seqAsListed.toLocaleString()));
         if (savedPct >= 5) {
-            lines.push(`    └ ⚠ 大檔排清單最後可降至 ${seqSorted.toLocaleString()}（本項省 ${savedPct}%）`);
+            lines.push(m(lang, "sequentialReadCanReduce", seqSorted.toLocaleString(), savedPct));
         }
         else {
-            lines.push(`    └ 目前順序已接近最佳（重排最多再省 ${savedPct}%）`);
+            lines.push(m(lang, "sequentialReadNearOptimal", savedPct));
         }
-        lines.push(`      本項不含初始 prompt 與工單（不受排序影響），故總成本的節省比例低於此數`);
+        lines.push(m(lang, "sequentialReadCostNote"));
     }
-    lines.push(`  最壞總消耗 ≈ ${worstTotal.toLocaleString()} tokens（各 spoke 之 cap 加總）`);
-    lines.push(`  並行度 ${cli.concurrency}`);
+    lines.push(m(lang, "worstCaseTotal", worstTotal.toLocaleString()));
+    lines.push(m(lang, "concurrencyLine", cli.concurrency));
     const byProvider = new Map();
     for (const spoke of spokes) {
         const est = estByAgent.get(spoke.agent) ?? 0;
@@ -89,12 +143,12 @@ export function buildReport(ticketId, spokes, estimates, allowlistEstimates, cli
     for (const [provider, { tpmLimit, peak }] of byProvider) {
         if (tpmLimit === null)
             continue;
-        lines.push(`  ${provider} tpmLimit ${tpmLimit.toLocaleString()}，靜態估算峰值 ${peak.toLocaleString()}`);
-        lines.push(`    └ 僅為靜態指標，不預測執行中的 TPM 曲線（429 等待會改變實際並行數）`);
+        lines.push(m(lang, "tpmPeakLine", provider, tpmLimit.toLocaleString(), peak.toLocaleString()));
+        lines.push(m(lang, "tpmPeakCaveat"));
     }
     const allowedCount = spokes.reduce((s, spoke) => s + spoke.allowedReadsResolved.length, 0);
-    lines.push(`  允許讀取 ${allowedCount} 個檔案，輸出至 ${outDir}/`);
-    const gitignoreWarning = formatGitignoreWarning(meta.gitignoreStatus, outDir);
+    lines.push(m(lang, "allowedReadsSummary", allowedCount, outDir));
+    const gitignoreWarning = formatGitignoreWarning(meta.gitignoreStatus, outDir, lang);
     if (gitignoreWarning)
         lines.push(gitignoreWarning);
     return lines.join("\n");