@ozzylabs/feedradar 0.2.1 → 0.2.3

package/dist/cli/triage.js

@@ -10,10 +10,27 @@ import { createProgressReporter } from "../core/progress.js";
 import { statusForTriageDecision } from "../core/transitions.js";
 import { buildTriagePrompt, parseTriageResponse, TriageResponseParseError, triageItems, } from "../core/triage/index.js";
 import { loadSources } from "../core/watcher.js";
+import { createTranslator } from "../i18n/index.js";
 import { TriageDecisionValueSchema } from "../schemas/item.js";
 import { AgentIdSchema } from "../schemas/research.js";
 import { SourceTriagePolicySchema } from "../schemas/source.js";
 import { resolveCommitPathInside } from "./_commit-path.js";
+import { LangFlagError, parseLangFlag, resolveWorkspaceLocale } from "./_locale.js";
+/**
+ * Validation error thrown by the sync `parseTriageRunArgs` that carries a
+ * message *key* instead of pre-rendered English (#336). The parser runs before
+ * the locale is resolved, so it tags the error with a catalog key and the
+ * caller renders it once the translator is in scope. Raw-token errors (unknown
+ * option / unexpected argument) stay plain `Error`s and echo verbatim.
+ */
+class TriageArgError extends Error {
+    key;
+    constructor(key) {
+        super(key);
+        this.key = key;
+        this.name = "TriageArgError";
+    }
+}
 function splitCsv(value) {
     return value
         .split(",")
@@ -39,19 +56,19 @@ function parseTriageRunArgs(args) {
         }
         if (a === "--dry-run") {
             if (out.mode)
-                throw new Error("--dry-run / --apply / --interactive are mutually exclusive");
+                throw new TriageArgError("cli.triage.modesExclusive");
             out.mode = "dry-run";
             continue;
         }
         if (a === "--apply") {
             if (out.mode)
-                throw new Error("--dry-run / --apply / --interactive are mutually exclusive");
+                throw new TriageArgError("cli.triage.modesExclusive");
             out.mode = "apply";
             continue;
         }
         if (a === "--interactive") {
             if (out.mode)
-                throw new Error("--dry-run / --apply / --interactive are mutually exclusive");
+                throw new TriageArgError("cli.triage.modesExclusive");
             out.mode = "interactive";
             continue;
         }
@@ -119,7 +136,7 @@ function parseTriageRunArgs(args) {
         throw new Error(`unexpected positional argument: ${a}`);
     }
     if (out.verbose && out.quiet) {
-        throw new Error("--verbose and --quiet are mutually exclusive");
+        throw new TriageArgError("cli.triage.verboseQuietExclusive");
     }
     return out;
 }
@@ -157,66 +174,14 @@ function parseTriageFeedbackArgs(args) {
     }
     return out;
 }
-function printRunHelp(log) {
-    log("Usage: radar triage [--dry-run | --apply | --interactive] [options]");
-    log("       radar triage --emit-payload [--source <id>] [options]");
-    log("       radar triage --commit <path>");
-    log("");
-    log("Classify `detected` items using the configured per-source triage policy.");
-    log("");
-    log("Modes (mutually exclusive; default: --dry-run):");
-    log("  --dry-run            print proposed decisions to stdout (no disk writes)");
-    log("  --apply              write decisions to items/<id>.yaml + transition status");
-    log("  --interactive        --dry-run output → $EDITOR → confirm → apply");
-    log("");
-    log("Options:");
-    log("  --source <id>            limit triage to a single source");
-    log("  --filter-tags <a,b>      matchedKeywords allow-list (comma-separated)");
-    log("  --triage-agent <id>      override policy.agent for this run");
-    log("  --policy <path>          override per-source policy with a YAML file");
-    log("  --max-items N            hard cap on items triaged in this run");
-    log("  --audit-log <path>       append JSONL audit records of every triage call");
-    log("  --emit-payload           Host-agent mode (ADR-0019): print the triage payload to");
-    log("                           stdout and DO NOT spawn an agent. The interactive host");
-    log("                           session classifies the items itself, writes a decisions");
-    log("                           JSON, then finalizes with `radar triage --commit <path>`.");
-    log("                           Requires a single source group: pass --source unless only");
-    log("                           one source has detected items. Interactive/opt-in only —");
-    log("                           CI/headless must use the default spawn path.");
-    log("  --commit <path>          Host-agent mode (ADR-0019): validate a host-written");
-    log("                           decisions JSON (under <cwd>/triage/) against the source's");
-    log("                           policy + detected items and apply the status transitions.");
-    log("  -v, --verbose            verbose progress output");
-    log("  -q, --quiet              suppress progress output entirely");
-    log("");
-    log("Sources missing a `triagePolicy:` block are skipped with a warning. See");
-    log("ADR-0018 for the policy schema reference.");
+function printRunHelp(t, log) {
+    log(t("cli.triage.runHelp"));
 }
-function printFeedbackHelp(log) {
-    log("Usage: radar triage feedback <item-id> --correct | --wrong [--reason <text>]");
-    log("");
-    log("Record human feedback on a prior triage decision (ADR-0018 §W5).");
-    log("Feedback is appended to items/<id>.yaml > triage.feedback, used by");
-    log("`radar triage stats` (#242) for policy tuning.");
-    log("");
-    log("Options:");
-    log("  --correct            mark the prior triage decision as correct");
-    log("  --wrong              mark the prior triage decision as wrong");
-    log("  --reason <text>      free-form rationale (recommended for --wrong)");
+function printFeedbackHelp(t, log) {
+    log(t("cli.triage.feedbackHelp"));
 }
-function printTriageHelp(log) {
-    log("Usage: radar triage <subcommand|--apply|--dry-run|--interactive> [...]");
-    log("");
-    log("Subcommands:");
-    log("  feedback <item-id> --correct | --wrong [--reason <text>]");
-    log("  stats [--since <duration>] [--source <id>] [--json]");
-    log("");
-    log("Run modes (when no subcommand given):");
-    log("  --dry-run            print proposed decisions");
-    log("  --apply              write decisions to items/<id>.yaml");
-    log("  --interactive        edit decisions in $EDITOR before applying");
-    log("");
-    log("Run `radar triage --help` for the full option list.");
+function printTriageHelp(t, log) {
+    log(t("cli.triage.help"));
 }
 async function pathExists(p) {
     try {
@@ -376,16 +341,16 @@ async function promptConfirm(message) {
  * resolved groups plus the full `detected` set (for the decision table) and the
  * items dir.
  */
-async function prepareTriageGroups(parsed, cwd, io) {
+async function prepareTriageGroups(parsed, cwd, io, t) {
     const { log, warn, error } = io;
     const sourcesDir = join(cwd, "sources");
     if (!(await pathExists(sourcesDir))) {
-        error("triage: no sources/ directory (run `radar init` first)");
+        error(t("cli.triage.noSourcesDir"));
         return { exitCode: 1 };
     }
     const sources = await loadSources(sourcesDir, error);
     if (sources.length === 0) {
-        log("triage: no sources defined; nothing to triage");
+        log(t("cli.triage.noSourcesDefined"));
         return { exitCode: 0 };
     }
     let policyOverride = null;
@@ -396,7 +361,7 @@ async function prepareTriageGroups(parsed, cwd, io) {
     }
     const itemsDir = join(cwd, "items");
     if (!(await pathExists(itemsDir))) {
-        log("triage: no items/ directory; nothing to triage");
+        log(t("cli.triage.noItemsDir"));
         return { exitCode: 0 };
     }
     let allItems;
@@ -415,11 +380,11 @@ async function prepareTriageGroups(parsed, cwd, io) {
         detected = detected.filter((i) => i.matchedKeywords.some((k) => tags.has(k)));
     }
     if (detected.length === 0) {
-        log("triage: no detected items match the filter (nothing to do)");
+        log(t("cli.triage.noDetectedMatch"));
         return { exitCode: 0 };
     }
     if (parsed.maxItems !== undefined && detected.length > parsed.maxItems) {
-        warn(`triage: ${detected.length} detected item(s) exceed --max-items ${parsed.maxItems}; processing the first ${parsed.maxItems} only`);
+        warn(t("cli.triage.maxItemsExceeded", { detected: detected.length, maxItems: parsed.maxItems }));
         detected = detected.slice(0, parsed.maxItems);
     }
     const sourcesById = new Map(sources.map((s) => [s.id, s]));
@@ -436,7 +401,7 @@ async function prepareTriageGroups(parsed, cwd, io) {
         const source = sourcesById.get(sourceId);
         const policy = policyOverride ?? source?.triagePolicy;
         if (!policy) {
-            warn(`triage: skipping ${groupItems.length} item(s) from source '${sourceId}' (no triagePolicy configured)`);
+            warn(t("cli.triage.skippingNoPolicy", { count: groupItems.length, sourceId }));
             continue;
         }
         const triageAgent = parsed.triageAgent ?? policy.agent;
@@ -444,7 +409,7 @@ async function prepareTriageGroups(parsed, cwd, io) {
         // agent call (or emitting a payload) — typos like `gemnini-cli` fail fast.
         const validated = AgentIdSchema.safeParse(triageAgent);
         if (!validated.success) {
-            error(`triage: --triage-agent '${triageAgent}' is not a valid agent id (claude-code | codex-cli | gemini-cli | copilot)`);
+            error(t("cli.triage.invalidTriageAgent", { agent: triageAgent }));
             return { exitCode: 2 };
         }
         groups.push({ sourceId, items: groupItems, policy, triageAgent });
@@ -487,20 +452,21 @@ const TriageDecisionsFileSchema = z.object({
  * detected items the user must narrow with `--source` (mirrors the ADR-0020
  * "one item set at a time" host-mode posture).
  */
-async function runTriageEmitPayload(parsed, cwd, io) {
+async function runTriageEmitPayload(parsed, cwd, io, t) {
     const { log, error } = io;
-    const prepared = await prepareTriageGroups(parsed, cwd, io);
+    const prepared = await prepareTriageGroups(parsed, cwd, io, t);
     if ("exitCode" in prepared)
         return prepared.exitCode;
     const { groups } = prepared;
     if (groups.length === 0) {
-        log("triage: no items were triaged (all sources skipped)");
+        log(t("cli.triage.noItemsTriaged"));
         return 0;
     }
     if (groups.length > 1) {
-        error(`triage: --emit-payload requires a single source group, but ${groups.length} sources have detected items (${groups
-            .map((g) => g.sourceId)
-            .join(", ")}). Narrow with --source <id>.`);
+        error(t("cli.triage.emitPayloadSingleSource", {
+            count: groups.length,
+            sources: groups.map((g) => g.sourceId).join(", "),
+        }));
         return 2;
     }
     const group = groups[0];
@@ -528,7 +494,7 @@ async function runTriageEmitPayload(parsed, cwd, io) {
  * host misled by injected content into committing an arbitrary path is rejected
  * at the CLI boundary.
  */
-async function runTriageCommit(parsed, commitPath, cwd, options, io) {
+async function runTriageCommit(parsed, commitPath, cwd, options, io, t) {
     const { log, warn, error } = io;
     const now = options.now ?? defaultNow;
     const guard = await resolveCommitPathInside(cwd, "triage", commitPath);
@@ -538,7 +504,7 @@ async function runTriageCommit(parsed, commitPath, cwd, options, io) {
     }
     const resolved = guard.resolved;
     if (!(await pathExists(resolved))) {
-        error(`triage: decisions file not found: ${resolved}`);
+        error(t("cli.triage.decisionsFileNotFound", { path: resolved }));
         return 1;
     }
     let raw;
@@ -570,7 +536,7 @@ async function runTriageCommit(parsed, commitPath, cwd, options, io) {
     // `triage.agent`). Reject upfront rather than persisting a bogus origin.
     const agentValid = AgentIdSchema.safeParse(file.agent);
     if (!agentValid.success) {
-        error(`triage: decisions file agent '${file.agent}' is not a valid agent id (claude-code | codex-cli | gemini-cli | copilot)`);
+        error(t("cli.triage.invalidDecisionsAgent", { agent: file.agent }));
         return 1;
     }
     const triageAgent = file.agent;
@@ -586,7 +552,7 @@ async function runTriageCommit(parsed, commitPath, cwd, options, io) {
     }
     const sourcesDir = join(cwd, "sources");
     if (!policyOverride && !(await pathExists(sourcesDir))) {
-        error("triage: no sources/ directory (run `radar init` first)");
+        error(t("cli.triage.noSourcesDir"));
         return 1;
     }
     let policy = policyOverride;
@@ -594,11 +560,11 @@ async function runTriageCommit(parsed, commitPath, cwd, options, io) {
         const sources = await loadSources(sourcesDir, error);
         const source = sources.find((s) => s.id === file.sourceId);
         if (!source) {
-            error(`triage: decisions file references unknown source '${file.sourceId}'`);
+            error(t("cli.triage.unknownSource", { sourceId: file.sourceId }));
             return 1;
         }
         if (!source.triagePolicy) {
-            error(`triage: source '${file.sourceId}' has no triagePolicy (cannot validate decisions; pass --policy <path>)`);
+            error(t("cli.triage.sourceNoPolicy", { sourceId: file.sourceId }));
             return 1;
         }
         policy = source.triagePolicy;
@@ -610,7 +576,7 @@ async function runTriageCommit(parsed, commitPath, cwd, options, io) {
     // spawn path's behavior.
     const itemsDir = join(cwd, "items");
     if (!(await pathExists(itemsDir))) {
-        error("triage: no items/ directory; nothing to commit");
+        error(t("cli.triage.noItemsDirCommit"));
         return 1;
     }
     let allItems;
@@ -623,7 +589,7 @@ async function runTriageCommit(parsed, commitPath, cwd, options, io) {
     }
     const detected = allItems.filter((i) => i.status === "detected");
     if (detected.length === 0) {
-        error(`triage: no detected items remain for source '${file.sourceId}' (already triaged, or wrong source?)`);
+        error(t("cli.triage.noDetectedForSource", { sourceId: file.sourceId }));
         return 1;
     }
     // Re-validate through the SAME parser the spawn path runs. We feed the raw
@@ -682,7 +648,7 @@ async function runTriageCommit(parsed, commitPath, cwd, options, io) {
         error(`triage: failed to write items: ${e instanceof Error ? e.message : String(e)}`);
         return 1;
     }
-    log(`triage: committed ${updated.length} decision(s) for source '${file.sourceId}'`);
+    log(t("cli.triage.committed", { count: updated.length, sourceId: file.sourceId }));
     for (const row of formatDecisionTable(detected, decisions))
         log(row);
     return 0;
@@ -692,6 +658,7 @@ async function runTriageCommit(parsed, commitPath, cwd, options, io) {
  * when the first positional is `feedback`, otherwise runs the triage flow.
  */
 export async function runTriage(args, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
     const log = options.io?.log ?? ((m) => console.log(m));
     const warn = options.io?.warn ?? ((m) => console.warn(m));
     const error = options.io?.error ?? ((m) => console.error(m));
@@ -703,7 +670,18 @@ export async function runTriage(args, options = {}) {
         return runTriageStats(rest, options, { log, warn, error });
     }
     if (first === "help") {
-        printTriageHelp(log);
+        // `help` subcommand: resolve a translator for the localized overview. A
+        // leading `--lang` is read-only here (no further args to forward).
+        const langFlag = (() => {
+            try {
+                return parseLangFlag(args).flag;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const locale = await resolveWorkspaceLocale({ flag: langFlag, cwd, warn: error });
+        printTriageHelp(createTranslator(locale), log);
         return 0;
     }
     // `--help` / `-h` flow through to the run-mode parser so the user sees
@@ -723,16 +701,34 @@ async function runTriageRun(args, options, io) {
     const { log, warn, error } = io;
     const cwd = options.cwd ?? process.cwd();
     const now = options.now ?? defaultNow;
+    // Strip `--lang <en|ja>` before `parseTriageRunArgs` (which rejects unknown
+    // flags), then resolve the UI locale for the help text.
+    let langState;
+    try {
+        langState = parseLangFlag(args);
+    }
+    catch (e) {
+        if (e instanceof LangFlagError) {
+            error(`triage: ${e.message}`);
+            return 2;
+        }
+        throw e;
+    }
+    const locale = await resolveWorkspaceLocale({ flag: langState.flag, cwd, warn: error });
+    const t = createTranslator(locale);
     let parsed;
     try {
-        parsed = parseTriageRunArgs(args);
+        parsed = parseTriageRunArgs(langState.rest);
     }
     catch (e) {
-        error(`triage: ${e instanceof Error ? e.message : String(e)}`);
+        // Keyed validation errors are translated now that the locale is resolved;
+        // raw-token errors (unknown option / unexpected argument) echo verbatim.
+        const message = e instanceof TriageArgError ? t(e.key) : e instanceof Error ? e.message : String(e);
+        error(`triage: ${message}`);
         return 2;
     }
     if (parsed.help) {
-        printRunHelp(log);
+        printRunHelp(t, log);
         return 0;
     }
     // Host-agent commit (#279 / ADR-0019). Independent of the run modes: it takes
@@ -740,23 +736,23 @@ async function runTriageRun(args, options, io) {
     // it must not be confused with `--dry-run` / `--apply` / `--interactive`.
     if (parsed.commit !== undefined) {
         if (parsed.mode) {
-            error("triage: --commit is incompatible with --dry-run / --apply / --interactive");
+            error(t("cli.triage.commitIncompatibleModes"));
             return 2;
         }
         if (parsed.emitPayload) {
-            error("triage: --commit is incompatible with --emit-payload");
+            error(t("cli.triage.commitIncompatibleEmitPayload"));
             return 2;
         }
-        return runTriageCommit(parsed, parsed.commit, cwd, options, io);
+        return runTriageCommit(parsed, parsed.commit, cwd, options, io, t);
     }
     // Host-agent emit (#279 / ADR-0019). Mutually exclusive with the apply / dry
     // / interactive run modes — it prints a payload instead of running an agent.
     if (parsed.emitPayload) {
         if (parsed.mode) {
-            error("triage: --emit-payload is incompatible with --dry-run / --apply / --interactive");
+            error(t("cli.triage.emitPayloadIncompatibleModes"));
             return 2;
         }
-        return runTriageEmitPayload(parsed, cwd, io);
+        return runTriageEmitPayload(parsed, cwd, io, t);
     }
     const mode = parsed.mode ?? "dry-run";
     // Progress reporter (#197 / ADR-0015). The triage CLI uses the spinner
@@ -768,7 +764,7 @@ async function runTriageRun(args, options, io) {
     const reporter = createProgressReporter({ level });
     // Shared PRE block: load + filter + group detected items and resolve each
     // group's policy / agent (also used by `--emit-payload`).
-    const prepared = await prepareTriageGroups(parsed, cwd, io);
+    const prepared = await prepareTriageGroups(parsed, cwd, io, t);
     if ("exitCode" in prepared)
         return prepared.exitCode;
     const { groups, detected, itemsDir } = prepared;
@@ -779,7 +775,11 @@ async function runTriageRun(args, options, io) {
     const allDecisions = new Map();
     const allErrors = [];
     for (const { sourceId, items: groupItems, policy, triageAgent } of groups) {
-        reporter.phase(`Triaging ${groupItems.length} item(s) from source '${sourceId}' via ${triageAgent}`);
+        reporter.phase(t("cli.triage.progressTriaging", {
+            count: groupItems.length,
+            sourceId,
+            agent: triageAgent,
+        }));
         let result;
         try {
             result = await triageItems(groupItems, {
@@ -807,13 +807,13 @@ async function runTriageRun(args, options, io) {
             warn(`triage: ${e}`);
     }
     if (allDecisions.size === 0) {
-        log("triage: no items were triaged (all sources skipped)");
+        log(t("cli.triage.noItemsTriaged"));
         return 0;
     }
     // Render the decision table. Used by every mode.
     const rows = formatDecisionTable(detected, allDecisions);
     if (mode === "dry-run") {
-        log("triage: dry-run — no changes written");
+        log(t("cli.triage.dryRunNoChanges"));
         for (const row of rows)
             log(row);
         return 0;
@@ -841,9 +841,9 @@ async function runTriageRun(args, options, io) {
             return 1;
         }
         const confirm = options.confirm ?? promptConfirm;
-        const confirmed = await confirm("Apply these decisions? [y/N]");
+        const confirmed = await confirm(t("cli.triage.confirmApply"));
         if (!confirmed) {
-            log("triage: aborted by user");
+            log(t("cli.triage.abortedByUser"));
             return 0;
         }
     }
@@ -855,7 +855,7 @@ async function runTriageRun(args, options, io) {
         error(`triage: failed to write items: ${e instanceof Error ? e.message : String(e)}`);
         return 1;
     }
-    log(`triage: applied ${allUpdated.length} decision(s)`);
+    log(t("cli.triage.applied", { count: allUpdated.length }));
     for (const row of rows)
         log(row);
     return 0;
@@ -874,34 +874,47 @@ async function runTriageFeedback(args, options) {
     const log = options.io?.log ?? ((m) => console.log(m));
     const error = options.io?.error ?? ((m) => console.error(m));
     const now = options.now ?? defaultNow;
+    let langState;
+    try {
+        langState = parseLangFlag(args);
+    }
+    catch (e) {
+        if (e instanceof LangFlagError) {
+            error(`triage feedback: ${e.message}`);
+            return 2;
+        }
+        throw e;
+    }
+    const locale = await resolveWorkspaceLocale({ flag: langState.flag, cwd, warn: error });
+    const t = createTranslator(locale);
     let parsed;
     try {
-        parsed = parseTriageFeedbackArgs(args);
+        parsed = parseTriageFeedbackArgs(langState.rest);
     }
     catch (e) {
         error(`triage feedback: ${e instanceof Error ? e.message : String(e)}`);
         return 2;
     }
     if (parsed.help) {
-        printFeedbackHelp(log);
+        printFeedbackHelp(t, log);
         return 0;
     }
     if (!parsed.itemId) {
-        error("triage feedback: missing <item-id>");
-        printFeedbackHelp(error);
+        error(t("cli.triage.feedbackMissingItemId"));
+        printFeedbackHelp(t, error);
         return 2;
     }
     if (parsed.correct && parsed.wrong) {
-        error("triage feedback: --correct and --wrong are mutually exclusive");
+        error(t("cli.triage.feedbackModesExclusive"));
         return 2;
     }
     if (!parsed.correct && !parsed.wrong) {
-        error("triage feedback: one of --correct | --wrong is required");
+        error(t("cli.triage.feedbackModeRequired"));
         return 2;
     }
     const itemsDir = join(cwd, "items");
     if (!(await pathExists(itemsDir))) {
-        error(`triage feedback: items/ not found (run \`radar init\`)`);
+        error(t("cli.triage.feedbackItemsDirNotFound"));
         return 1;
     }
     let items;
@@ -914,11 +927,11 @@ async function runTriageFeedback(args, options) {
     }
     const item = items.find((i) => i.id === parsed.itemId);
     if (!item) {
-        error(`triage feedback: item '${parsed.itemId}' not found under items/`);
+        error(t("cli.triage.feedbackItemNotFound", { id: parsed.itemId }));
         return 1;
     }
     if (!item.triage) {
-        error(`triage feedback: item '${item.id}' has no prior triage decision to give feedback on`);
+        error(t("cli.triage.feedbackNoPriorDecision", { id: item.id }));
         return 1;
     }
     // Overwrite-semantic: replace the existing feedback array with a single
@@ -947,7 +960,7 @@ async function runTriageFeedback(args, options) {
         return 1;
     }
     const verdict = parsed.correct ? "correct" : "wrong";
-    log(`triage feedback: items/${item.sourceId}/${item.id}.yaml feedback -> ${verdict}`);
+    log(t("cli.triage.feedbackRecorded", { sourceId: item.sourceId, id: item.id, verdict }));
     return 0;
 }
 function parseTriageStatsArgs(args) {
@@ -983,19 +996,8 @@ function parseTriageStatsArgs(args) {
     }
     return out;
 }
-function printStatsHelp(log) {
-    log("Usage: radar triage stats [--since <duration>] [--source <id>] [--json]");
-    log("");
-    log("Aggregate triage decisions and human feedback (ADR-0018 §W5, #242).");
-    log("Use after running `radar triage --apply` for some weeks; the output");
-    log("highlights precision / recall drift and suggests `triagePolicy.rules:`");
-    log("tweaks. See docs/user-guide.md `policy tuning workflow` for the");
-    log("recommended monthly loop.");
-    log("");
-    log("Options:");
-    log("  --since <duration>   only count items triaged within the cutoff (e.g. 30d, 24h)");
-    log("  --source <id>        limit stats to a single source (default: all sources)");
-    log("  --json               emit machine-readable JSON instead of the text report");
+function printStatsHelp(t, log) {
+    log(t("cli.triage.statsHelp"));
 }
 /**
  * Parse `Nd | Nh | Nm | Ns` into a `Date` cutoff. Returns `null` when the
@@ -1298,23 +1300,36 @@ async function runTriageStats(args, options, io) {
     const cwd = options.cwd ?? process.cwd();
     const nowFn = options.now ?? defaultNow;
     const now = new Date(nowFn());
+    let langState;
+    try {
+        langState = parseLangFlag(args);
+    }
+    catch (e) {
+        if (e instanceof LangFlagError) {
+            error(`triage stats: ${e.message}`);
+            return 2;
+        }
+        throw e;
+    }
+    const locale = await resolveWorkspaceLocale({ flag: langState.flag, cwd, warn: error });
+    const t = createTranslator(locale);
     let parsed;
     try {
-        parsed = parseTriageStatsArgs(args);
+        parsed = parseTriageStatsArgs(langState.rest);
     }
     catch (e) {
         error(`triage stats: ${e instanceof Error ? e.message : String(e)}`);
         return 2;
     }
     if (parsed.help) {
-        printStatsHelp(log);
+        printStatsHelp(t, log);
         return 0;
     }
     let sinceCutoff = null;
     if (parsed.since) {
         sinceCutoff = parseSinceCutoffForStats(parsed.since, now);
         if (!sinceCutoff) {
-            error(`triage stats: invalid --since '${parsed.since}' (expected Ns | Nm | Nh | Nd)`);
+            error(t("cli.triage.statsInvalidSince", { since: parsed.since }));
             return 2;
         }
     }
@@ -1328,7 +1343,7 @@ async function runTriageStats(args, options, io) {
             }, null, 2));
         }
         else {
-            log("triage stats: no items/ directory (run `radar init` first)");
+            log(t("cli.triage.statsNoItemsDir"));
         }
         return 0;
     }
@@ -1382,7 +1397,7 @@ async function runTriageStats(args, options, io) {
         return 0;
     }
     if (perSource.length === 0) {
-        log("triage stats: no triaged items match the filter (nothing to report)");
+        log(t("cli.triage.statsNoMatch"));
         return 0;
     }
     let first = true;
@@ -1409,7 +1424,8 @@ export const __test__ = {
 };
 export const triageCommand = {
     name: "triage",
-    summary: "LLM-based triage of detected items (ADR-0018)",
+    summary: "LLM-based triage of detected items",
+    summaryKey: "cli.summary.triage",
     run: (args) => runTriage(args),
 };
 //# sourceMappingURL=triage.js.map