dowafu 0.1.0 → 0.3.0

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");

package/dist/runner.js

@@ -3,15 +3,23 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { buildFinalizeUserText, buildFirstUserText, buildSystemPrompt } from "./prompt.js";
-import { ALLOWLIST_REJECT_MESSAGE, checkAllowlist } from "./whitelist.js";
+import { allowlistRejectMessage, checkAllowlist } from "./whitelist.js";
 import { findUnknownUsageKeys, sumUsage, usageProviderKeyFor } from "./usage.js";
 import { estimateCostUsd } from "./cost.js";
 import { describeError, ProviderHttpError } from "./mask.js";
 import { parseRetryAfter } from "./rate-limit.js";
 import { RawIntegrityError } from "./raw-integrity.js";
 import { classifyError } from "./error-classify.js";
+import { m } from "./messages.js";
 const MAX_FILE_BYTES = 200 * 1024; // §13：單檔 200KB 上限，防「單輪讀入巨檔」異常
 const MAX_ROUNDS = 60; // 安全上限，遠高於實務上的 --max-tool-calls，純防無窮迴圈 bug
+// i18n_classification_t2.md §三之1：這兩則都成為 executeToolCall／runSpoke 的
+// resultText，被 push 進 conv.turns 送往外部 API——消費者是 spoke 不是人類，歸 C 類，
+// 不進 messages.ts，由 spoke.lang 直接選用（同 whitelist.ts 的 allowlistRejectMessage）。
+const FILE_TRUNCATED_SUFFIX = "\n...(檔案超過 200KB 上限，內容已截斷)";
+const FILE_TRUNCATED_SUFFIX_EN = "\n...(file exceeds the 200KB limit; content truncated)";
+const TOOL_LIMIT_REACHED_MESSAGE = "已達 --max-tool-calls 上限，未執行";
+const TOOL_LIMIT_REACHED_MESSAGE_EN = "The --max-tool-calls limit has been reached; not executed.";
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -21,7 +29,7 @@ async function executeToolCall(call, spoke, repoRoot) {
     const check = checkAllowlist(spoke.allowSet, requestedPath, repoRoot);
     if (!check.allowed) {
         return {
-            resultText: ALLOWLIST_REJECT_MESSAGE,
+            resultText: allowlistRejectMessage(spoke.lang),
             log: { path: requestedPath, allowed: false, reason: check.reason, startedAt, durationMs: Date.now() - startedAt },
         };
     }
@@ -29,7 +37,8 @@ async function executeToolCall(call, spoke, repoRoot) {
         const buf = await readFile(check.realPath);
         let content = buf.toString("utf8");
         if (buf.byteLength > MAX_FILE_BYTES) {
-            content = buf.subarray(0, MAX_FILE_BYTES).toString("utf8") + "\n...(檔案超過 200KB 上限，內容已截斷)";
+            const suffix = spoke.lang === "en" ? FILE_TRUNCATED_SUFFIX_EN : FILE_TRUNCATED_SUFFIX;
+            content = buf.subarray(0, MAX_FILE_BYTES).toString("utf8") + suffix;
         }
         return {
             resultText: content,
@@ -38,7 +47,7 @@ async function executeToolCall(call, spoke, repoRoot) {
     }
     catch {
         return {
-            resultText: ALLOWLIST_REJECT_MESSAGE,
+            resultText: allowlistRejectMessage(spoke.lang),
             log: { path: requestedPath, allowed: false, reason: "not_found", startedAt, durationMs: Date.now() - startedAt },
         };
     }
@@ -68,19 +77,19 @@ async function sendWithResilience(adapter, conv, sendOpts, cfg, ctx) {
                 // §8：raw 完整性違反是實作缺陷，不是 API 錯誤——重試只會確定性地再次觸發同一個
                 // bug（下一輪的 conv 結構仍帶著同樣的漏洞），不消耗任何網路呼叫也不可能成功。
                 // 立即判定失敗，不進入一般失敗的重試計數。
-                recordError(err, `raw 完整性檢查失敗（實作缺陷，不重試）：${err.message}`, null);
+                recordError(err, m(ctx.lang, "rawIntegrityCheckFailed", err.message), null);
                 return { ok: false, kind: "failed" };
             }
             const info = describeError(err);
             if (info.is429) {
                 rateLimitAttempt++;
                 if (rateLimitAttempt > cfg.rateLimitRetries) {
-                    recordError(err, `429 撞牆次數超過 --rate-limit-retries (${cfg.rateLimitRetries})`, info.status ?? 429, info.errorBody);
+                    recordError(err, m(ctx.lang, "rateLimitRetriesExceeded", cfg.rateLimitRetries), info.status ?? 429, info.errorBody);
                     return { ok: false, kind: "rate_limited" };
                 }
                 const { seconds, source } = parseRetryAfter(info.retryAfterHeader, info.message, rateLimitAttempt - 1);
                 if (seconds > cfg.maxRateWaitSec) {
-                    recordError(err, `429 要求等待 ${seconds}s，超過 --max-rate-wait ${cfg.maxRateWaitSec}s`, info.status ?? 429, info.errorBody);
+                    recordError(err, m(ctx.lang, "rateLimitWaitExceeded", seconds, cfg.maxRateWaitSec), info.status ?? 429, info.errorBody);
                     return { ok: false, kind: "rate_limited" };
                 }
                 ctx.rateLimitHits.push({ at: Date.now(), waitSeconds: seconds, source });
@@ -157,6 +166,7 @@ export async function runSpoke(spoke, adapter, ticketDir, options) {
             addWaitedMs: (ms) => {
                 waitedMs += ms;
             },
+            lang: spoke.lang,
         });
         if (!outcome.ok) {
             const hasContent = rawResponses.length > 0;
@@ -206,7 +216,7 @@ export async function runSpoke(spoke, adapter, ticketDir, options) {
         conv.turns.push(result.turn);
         if (!result.usage.available) {
             status = "truncated:usage_unavailable";
-            errors.push(`round ${round}: usage 不可用（usageMissing），保守收束`);
+            errors.push(m(spoke.lang, "usageUnavailableRound", round));
             finalText = result.meta.text ?? finalText;
             if (toolCallsThisRound.length === 0 || finalizeMode)
                 break;
@@ -220,7 +230,7 @@ export async function runSpoke(spoke, adapter, ticketDir, options) {
         }
         if (finalizeMode) {
             // 收束呼叫理論上不帶 tool，仍收到 tool call 屬異常，防禦性丟棄不執行
-            errors.push(`round ${round}: 收束呼叫仍回傳 tool call，忽略`);
+            errors.push(m(spoke.lang, "finalizeToolCallIgnored", round));
             finalText = result.meta.text;
             break;
         }
@@ -267,7 +277,8 @@ export async function runSpoke(spoke, adapter, ticketDir, options) {
                 };
                 toolCalls.push(log);
                 options.onEvent({ type: "tool_call", agent: spoke.agent, path: log.path, allowed: false, reason: log.reason });
-                conv.turns.push({ role: "tool", callId: call.id, result: "已達 --max-tool-calls 上限，未執行" });
+                const limitMessage = spoke.lang === "en" ? TOOL_LIMIT_REACHED_MESSAGE_EN : TOOL_LIMIT_REACHED_MESSAGE;
+                conv.turns.push({ role: "tool", callId: call.id, result: limitMessage });
                 continue;
             }
             const { resultText, log } = await executeToolCall(call, spoke, options.repoRoot);