@ozzylabs/feedradar 0.2.1 → 0.2.2

package/dist/cli/research.js

@@ -23,8 +23,10 @@ import { getDefaultAgent, loadRadarConfig, RadarConfigError } from "../core/conf
 import { loadItems, saveItems } from "../core/items.js";
 import { loadTemplate } from "../core/templates.js";
 import { isValidTransition } from "../core/transitions.js";
+import { createTranslator } from "../i18n/index.js";
 import { AgentIdSchema, ResearchFrontmatterSchema } from "../schemas/index.js";
 import { resolveCommitPathInside } from "./_commit-path.js";
+import { LangFlagError, resolveCommandLocale } from "./_locale.js";
 import { buildAgentProgressCallback, buildReporter, ProgressFlagError, parseProgressFlags, pollOutputFileSize, } from "./_progress.js";
 /**
  * Default hard-cap for `radar research --batch`.
@@ -114,55 +116,8 @@ function parseArgs(args) {
     }
     return out;
 }
-function printHelp(log) {
-    log("Usage:");
-    log("  radar research <item-id> [--agent <agent-id>] [--template <template-id>]");
-    log("  radar research --digest <item-id> <item-id> ... [--triage-group <group>] [--agent <agent-id>] [--template <id>]");
-    log(`  radar research --batch [--status <status>] [--max-items N] [--filter-tags <list>] [--agent <id>]`);
-    log("  radar research <item-id> --emit-payload [--digest <ids...>] [--template <id>]");
-    log("  radar research --commit <path>");
-    log("");
-    log("Arguments:");
-    log("  <item-id>             Item id (matches items/<sourceId>/<item-id>.yaml)");
-    log("                        Pass 2 or more ids together with --digest to bundle them.");
-    log("                        Omit positional ids with --batch — items are discovered.");
-    log("");
-    log("Options:");
-    log("  --agent <agent-id>    claude-code | codex-cli | gemini-cli | copilot (default: claude-code)");
-    log("  --template <id>       Template id under templates/ (default: default; digest: digest)");
-    log("  --digest              Bundle multiple items into a single digest report (ADR-0011)");
-    log("  --triage-group <group> Digest-mode slug source (ADR-0018 §W-H): name the digest");
-    log("                        file after this triage.group instead of the matchedKeywords");
-    log("                        frequency. Required to keep per-group digests unique on the");
-    log("                        same day when a single-keyword source emits multiple groups");
-    log("                        (#255). Falls back to the matchedKeywords slug when omitted.");
-    log("  --batch               Research every item matching --status (and --filter-tags)");
-    log("                        respecting the --max-items hard-cap (ADR-0014 D3a).");
-    log("  --status <status>     Batch-mode filter: detected | triaged_research");
-    log("                        (default: detected). `triaged_research` consumes items");
-    log("                        the triage adapter promoted (ADR-0018 §W-B) and");
-    log("                        transitions them to `researched` on success.");
-    log(`  --max-items N         Batch-mode hard-cap on processed items (default: ${RESEARCH_BATCH_DEFAULT_MAX_ITEMS}).`);
-    log("                        Excess items are dropped and announced via warn() so a runaway");
-    log("                        detection cannot blow the cap from inside a workflow.");
-    log("  --filter-tags <list>  Batch-mode comma-separated allow-list matched against");
-    log("                        each item's matchedKeywords (case-insensitive). Default: all.");
-    log("  --emit-payload        Host-agent mode (ADR-0019): print the research payload to");
-    log("                        stdout and DO NOT spawn an agent. The interactive host");
-    log("                        session runs the SKILL procedure itself, then finalizes");
-    log("                        with `radar research --commit <path>`. Interactive/opt-in");
-    log("                        only — CI/headless must use the default spawn path.");
-    log("  --commit <path>       Host-agent mode (ADR-0019): validate an externally-written");
-    log("                        report (under <cwd>/research/) against ResearchFrontmatter-");
-    log("                        Schema and apply the detected → researched transition.");
-    log("  --verbose             Stream the agent CLI's stdout/stderr in addition to phase markers.");
-    log("  --quiet               Suppress phase markers and spinner; print only the completion line.");
-    log("                        Equivalent to setting RADAR_NO_PROGRESS=1 (ADR-0015 D2).");
-    log("");
-    log("Output:");
-    log("  single-item:  research/<YYYYMMDD>_<slug>_v1.md (ADR-0003)");
-    log("  digest:       research/<YYYYMMDD>_digest_<slug>_v1.md (ADR-0011)");
-    log("  batch:        one single-item report per matched item (no digest aggregation).");
+function printHelp(t, log) {
+    log(t("cli.research.help", { maxItems: RESEARCH_BATCH_DEFAULT_MAX_ITEMS }));
 }
 async function pathExists(p) {
     try {
@@ -295,12 +250,12 @@ async function findItems(cwd, itemIds) {
     }
     return { items: matched };
 }
-async function resolveAgent(cwd, rawAgent, error) {
+async function resolveAgent(cwd, rawAgent, error, t) {
     let explicitAgent;
     if (rawAgent !== undefined) {
         const agentResult = AgentIdSchema.safeParse(rawAgent);
         if (!agentResult.success) {
-            error(`research: invalid --agent '${rawAgent}' (expected: claude-code | codex-cli | gemini-cli | copilot)`);
+            error(t("cli.agent.invalid", { cmd: "research", agent: rawAgent }));
             return { exitCode: 2 };
         }
         explicitAgent = agentResult.data;
@@ -332,7 +287,7 @@ async function resolveAgent(cwd, rawAgent, error) {
  * collision backstop as the spawn path, without the model-call step.
  */
 async function prepareResearch(params) {
-    const { cwd, items, digest, templateId, now, triageGroup, warn, error, progress } = params;
+    const { cwd, items, digest, templateId, now, triageGroup, warn, error, progress, t } = params;
     for (const item of items) {
         if (item.injectionFlags.length > 0) {
             warn(`research: item '${item.id}' has ${item.injectionFlags.length} injection flag(s): ${item.injectionFlags.join(", ")} (audit-only; use \`radar dismiss\` to skip)`);
@@ -352,16 +307,18 @@ async function prepareResearch(params) {
     }
     const outputPath = join(cwd, "research", filename);
     if (await pathExists(outputPath)) {
-        error(`research: ${outputPath} already exists (use \`radar update\` to re-research)`);
+        error(t("cli.research.alreadyExists", { path: outputPath }));
         return { exitCode: 1 };
     }
     // Phase marker: items resolved (ADR-0015 D4 "Loaded <noun>"). One marker
     // per invocation regardless of digest cardinality so the progress stream
     // stays uniform between single / digest / batch modes.
-    progress.phase(digest ? `Loaded ${items.length} items` : `Loaded item: ${items[0].id}`, items.map((i) => i.id).join(", "));
+    progress.phase(digest
+        ? t("cli.progress.loadedItems", { count: items.length })
+        : t("cli.progress.loadedItem", { id: items[0].id }), items.map((i) => i.id).join(", "));
     // Phase marker: template resolved. Echoes the actual template id so a
     // user running `--template deep-dive` sees the value flow through.
-    progress.phase(`Loaded template: ${templateId}.md`);
+    progress.phase(t("cli.progress.loadedTemplate", { templateId }));
     return { outputPath, filename };
 }
 /**
@@ -381,7 +338,7 @@ async function prepareResearch(params) {
  * of them.
  */
 async function finalizeResearch(params) {
-    const { cwd, outputPath, log, warn, error, progress } = params;
+    const { cwd, outputPath, log, warn, error, progress, t } = params;
     if (!(await pathExists(outputPath))) {
         error(`research: report was not written to ${outputPath} (did not write the output path?)`);
         return 1;
@@ -413,7 +370,7 @@ async function finalizeResearch(params) {
     // Phase marker: schema check passed. Emitted before the status transition
     // so the user sees the validation outcome separately from the items.yaml
     // write that follows.
-    progress.phase("Frontmatter validated");
+    progress.phase(t("cli.progress.frontmatterValidated"));
     const reviewedDrift = fmResult.data.reviewedAt !== null || fmResult.data.reviewedBy !== null;
     const supersedesDrift = fmResult.data.supersedes !== null;
     if (reviewedDrift || supersedesDrift) {
@@ -483,21 +440,25 @@ async function finalizeResearch(params) {
         error(`  (research file was written: ${outputPath})`);
         return 1;
     }
-    log(`research: wrote ${outputPath}`);
+    log(t("cli.research.wrote", { path: outputPath }));
     for (const item of updated) {
         const from = transitions.get(item.id);
         if (from !== undefined && item.status === "researched") {
             // Phase marker: status transition. We emit one phase per item rather
             // than collapsing them so the digest case stays explicit about what
             // moved. The arrow uses U+2192 (→) per ADR-0015 D4 examples.
-            progress.phase(`Status: ${from} → researched`, `items/${item.sourceId}/${item.id}.yaml`);
-            log(`research: items/${item.sourceId}/${item.id}.yaml status -> researched`);
+            progress.phase(t("cli.progress.statusTransition", { from, to: "researched" }), `items/${item.sourceId}/${item.id}.yaml`);
+            log(t("cli.research.transitioned", { sourceId: item.sourceId, id: item.id }));
         }
     }
     return 0;
 }
 async function processResearchInvocation(params) {
-    const { cwd, items, digest, agent, templateId, template, now, triageGroup, log, warn, error, progress, } = params;
+    const { cwd, items, digest, agent, templateId, template, locale, now, triageGroup, log, warn, error, progress, } = params;
+    // Translator for the user-facing progress phase labels (#313). Derived from
+    // the same resolved locale already used for the report-output language
+    // (#316) so the spinner / phase markers and the report body agree.
+    const t = createTranslator(locale);
     const prepared = await prepareResearch({
         cwd,
         items,
@@ -508,6 +469,7 @@ async function processResearchInvocation(params) {
         warn,
         error,
         progress,
+        t,
     });
     if ("exitCode" in prepared)
         return prepared.exitCode;
@@ -520,8 +482,8 @@ async function processResearchInvocation(params) {
     // Phase marker + spinner: agent spawn. We pair `phase("Spawning …")` with
     // `start("Agent running…")` so the marker is printed once for scrollback
     // and the spinner row carries the live `[mm:ss]` heartbeat + metrics.
-    progress.phase(`Spawning ${agent}`, `cwd: ${cwd}`);
-    progress.start("Agent running");
+    progress.phase(t("cli.progress.spawning", { agent }), `cwd: ${cwd}`);
+    progress.start(t("cli.progress.agentRunning"));
     const adapterStartedAt = Date.now();
     const polling = pollOutputFileSize({ path: outputPath, reporter: progress });
     let adapterExitCode = 0;
@@ -533,13 +495,14 @@ async function processResearchInvocation(params) {
             items,
             outputPath,
             cwd,
+            locale,
             onProgress: buildAgentProgressCallback(progress),
         });
     }
     catch (e) {
         adapterExitCode = 1;
         polling.stop();
-        progress.fail("Agent failed", e instanceof Error ? e.message : String(e));
+        progress.fail(t("cli.progress.agentFailed"), e instanceof Error ? e.message : String(e));
         error(`research: adapter failed: ${e instanceof Error ? e.message : String(e)}`);
         return 1;
     }
@@ -547,9 +510,9 @@ async function processResearchInvocation(params) {
         polling.stop();
     }
     if (adapterExitCode === 0) {
-        progress.succeed(`Agent completed (exit ${adapterExitCode})`, Date.now() - adapterStartedAt);
+        progress.succeed(t("cli.progress.agentCompleted", { exitCode: adapterExitCode }), Date.now() - adapterStartedAt);
     }
-    return finalizeResearch({ cwd, outputPath, items, log, warn, error, progress });
+    return finalizeResearch({ cwd, outputPath, items, log, warn, error, progress, t });
 }
 /**
  * Host-agent emit path (#254 / ADR-0019): run the same PRE block as the spawn
@@ -559,7 +522,7 @@ async function processResearchInvocation(params) {
  * `radar research --commit`.
  */
 async function runResearchEmitPayload(params) {
-    const { cwd, items, digest, agent, templateId, template, now, triageGroup, log, warn, error, progress, } = params;
+    const { cwd, items, digest, agent, templateId, template, now, triageGroup, log, warn, error, progress, t, } = params;
     const prepared = await prepareResearch({
         cwd,
         items,
@@ -570,6 +533,7 @@ async function runResearchEmitPayload(params) {
         warn,
         error,
         progress,
+        t,
     });
     if ("exitCode" in prepared)
         return prepared.exitCode;
@@ -594,7 +558,7 @@ async function runResearchEmitPayload(params) {
  * code, not just SKILL guidance).
  */
 async function runResearchCommit(params) {
-    const { cwd, commitPath, log, warn, error, progress } = params;
+    const { cwd, commitPath, log, warn, error, progress, t } = params;
     const guard = await resolveCommitPathInside(cwd, "research", commitPath);
     if ("error" in guard) {
         error(`research: ${guard.error}`);
@@ -608,18 +572,19 @@ async function runResearchCommit(params) {
         warn,
         error,
         progress,
+        t,
     });
 }
-function parseMaxItems(raw, error) {
+function parseMaxItems(raw, error, t) {
     if (raw === undefined)
         return RESEARCH_BATCH_DEFAULT_MAX_ITEMS;
     if (!/^[0-9]+$/.test(raw)) {
-        error(`research: invalid --max-items '${raw}' (expected positive integer)`);
+        error(t("cli.research.invalidMaxItemsInteger", { raw }));
         return null;
     }
     const n = Number.parseInt(raw, 10);
     if (!Number.isFinite(n) || n <= 0) {
-        error(`research: invalid --max-items '${raw}' (must be > 0)`);
+        error(t("cli.research.invalidMaxItemsPositive", { raw }));
         return null;
     }
     return n;
@@ -634,30 +599,33 @@ function parseFilterTags(raw) {
             .filter((s) => s.length > 0)),
     ];
 }
-async function runResearchBatch(parsed, cwd, log, warn, error, progress) {
+async function runResearchBatch(parsed, cwd, locale, log, warn, error, progress, t) {
     if (parsed.itemIds.length > 0) {
-        error(`research: --batch is incompatible with positional <item-id> arguments (got ${parsed.itemIds.length})`);
+        error(t("cli.research.batchIncompatiblePositional", { count: parsed.itemIds.length }));
         return 2;
     }
     if (parsed.digest) {
-        error("research: --batch is incompatible with --digest");
+        error(t("cli.research.batchIncompatibleDigest"));
         return 2;
     }
     if (parsed.triageGroup !== undefined) {
-        error("research: --batch is incompatible with --triage-group");
+        error(t("cli.research.batchIncompatibleTriageGroup"));
         return 2;
     }
     const rawStatus = parsed.status ?? "detected";
     if (!RESEARCH_BATCH_ALLOWED_STATUSES.includes(rawStatus)) {
-        error(`research: invalid --status '${rawStatus}' (expected: ${RESEARCH_BATCH_ALLOWED_STATUSES.join(" | ")})`);
+        error(t("cli.research.invalidStatus", {
+            status: rawStatus,
+            allowed: RESEARCH_BATCH_ALLOWED_STATUSES.join(" | "),
+        }));
         return 2;
     }
     const status = rawStatus;
-    const maxItems = parseMaxItems(parsed.maxItems, error);
+    const maxItems = parseMaxItems(parsed.maxItems, error, t);
     if (maxItems === null)
         return 2;
     const filterTags = parseFilterTags(parsed.filterTags);
-    const agentResult = await resolveAgent(cwd, parsed.agent, error);
+    const agentResult = await resolveAgent(cwd, parsed.agent, error, t);
     if ("exitCode" in agentResult)
         return agentResult.exitCode;
     const agent = agentResult.agent;
@@ -689,17 +657,24 @@ async function runResearchBatch(parsed, cwd, log, warn, error, progress) {
             return ap < bp ? -1 : 1;
         return a.id.localeCompare(b.id);
     });
+    const tagsSuffix = filterTags.length > 0 ? `, tags=${filterTags.join(",")}` : "";
     if (matches.length === 0) {
-        log(`research: no items matched --batch filters (status=${status}${filterTags.length > 0 ? `, tags=${filterTags.join(",")}` : ""})`);
+        log(t("cli.research.noItemsMatched", { status, tags: tagsSuffix }));
         return 0;
     }
     let selected = matches;
     if (matches.length > maxItems) {
         const dropped = matches.length - maxItems;
-        warn(`research: --max-items ${maxItems} cap reached; dropping ${dropped} excess item(s) (matched ${matches.length})`);
+        warn(t("cli.research.capReached", { maxItems, dropped, matched: matches.length }));
         selected = matches.slice(0, maxItems);
     }
-    log(`research: --batch will process ${selected.length} item(s) (status=${status}${filterTags.length > 0 ? `, tags=${filterTags.join(",")}` : ""}, agent=${agent}, cap=${maxItems})`);
+    log(t("cli.research.batchWillProcess", {
+        count: selected.length,
+        status,
+        tags: tagsSuffix,
+        agent,
+        cap: maxItems,
+    }));
     const now = new Date();
     for (const item of selected) {
         const exitCode = await processResearchInvocation({
@@ -709,6 +684,7 @@ async function runResearchBatch(parsed, cwd, log, warn, error, progress) {
             agent,
             templateId,
             template,
+            locale,
             now,
             log,
             warn,
@@ -716,11 +692,11 @@ async function runResearchBatch(parsed, cwd, log, warn, error, progress) {
             progress,
         });
         if (exitCode !== 0) {
-            error(`research: --batch halted on item '${item.id}' (exit ${exitCode})`);
+            error(t("cli.research.batchHalted", { id: item.id, exitCode }));
             return exitCode;
         }
     }
-    log(`research: --batch completed ${selected.length} item(s)`);
+    log(t("cli.research.batchCompleted", { count: selected.length }));
     return 0;
 }
 export async function runResearch(args, options = {}) {
@@ -743,20 +719,56 @@ export async function runResearch(args, options = {}) {
         }
         throw e;
     }
-    // Tests inject a reporter directly; production constructs one from the
-    // flag state. Either way the per-invocation state stays local — there is
-    // no shared global reporter, so concurrent CLI invocations are isolated.
-    const progress = options.progress ?? buildReporter({ level: progressState.level });
+    // Resolve the report-output locale (#316) BEFORE the command-specific parser
+    // sees argv: `resolveCommandLocale` strips `--lang` so `parseArgs` never trips
+    // on it (mirrors the `--verbose` / `--quiet` strip above). `config.locale` is
+    // the lowest-priority source; we read it best-effort here (RadarConfigError is
+    // surfaced authoritatively by `resolveAgent` below, so we tolerate it as
+    // "no config locale" and let the agent resolver report the malformed config).
+    // Resolved first so the progress reporter (#313) and the report-output
+    // language (#316) share the same locale.
+    let configLocale;
+    try {
+        configLocale = (await loadRadarConfig(cwd)).locale;
+    }
+    catch {
+        configLocale = undefined;
+    }
+    let langRest;
+    let locale;
+    try {
+        const resolved = resolveCommandLocale(progressState.rest, configLocale, { warn });
+        langRest = resolved.rest;
+        locale = resolved.locale;
+    }
+    catch (e) {
+        if (e instanceof LangFlagError) {
+            error(`research: ${e.message}`);
+            return 2;
+        }
+        throw e;
+    }
+    // Tests inject a reporter directly; production constructs one from the flag
+    // state + resolved locale (so the reporter's phase labels are localized,
+    // #313). Either way the per-invocation state stays local — there is no shared
+    // global reporter, so concurrent CLI invocations are isolated.
+    const progress = options.progress ?? buildReporter({ level: progressState.level, locale });
+    // Translator for the user-facing progress phase labels (#313), bound to the
+    // resolved locale. Threaded into the phase-emitting helpers below so the
+    // milestone strings track the report-output language. Built independently of
+    // `progress` so a test-injected reporter (which has no bundled translator)
+    // still gets localized phase labels.
+    const t = createTranslator(locale);
     let parsed;
     try {
-        parsed = parseArgs(progressState.rest);
+        parsed = parseArgs(langRest);
     }
     catch (e) {
         error(`research: ${e instanceof Error ? e.message : String(e)}`);
         return 2;
     }
     if (parsed.help) {
-        printHelp(log);
+        printHelp(t, log);
         return 0;
     }
     // Host-agent commit (#254 / ADR-0019). Independent of agent / template /
@@ -765,64 +777,78 @@ export async function runResearch(args, options = {}) {
     // <item-id> arguments.
     if (parsed.commit !== undefined) {
         if (parsed.batch) {
-            error("research: --commit is incompatible with --batch");
+            error(t("cli.research.commitIncompatibleBatch"));
             return 2;
         }
         if (parsed.digest) {
-            error("research: --commit is incompatible with --digest");
+            error(t("cli.research.commitIncompatibleDigest"));
             return 2;
         }
         if (parsed.emitPayload) {
-            error("research: --commit is incompatible with --emit-payload");
+            error(t("cli.research.commitIncompatibleEmitPayload"));
             return 2;
         }
         if (parsed.triageGroup !== undefined) {
-            error("research: --commit is incompatible with --triage-group");
+            error(t("cli.research.commitIncompatibleTriageGroup"));
             return 2;
         }
         if (parsed.itemIds.length > 0) {
-            error(`research: --commit takes a <path>, not <item-id> arguments (got ${parsed.itemIds.length}: ${parsed.itemIds.join(", ")})`);
+            error(t("cli.research.commitTakesPath", {
+                count: parsed.itemIds.length,
+                ids: parsed.itemIds.join(", "),
+            }));
             return 2;
         }
-        return runResearchCommit({ cwd, commitPath: parsed.commit, log, warn, error, progress });
+        return runResearchCommit({
+            cwd,
+            commitPath: parsed.commit,
+            log,
+            warn,
+            error,
+            progress,
+            t,
+        });
     }
     if (parsed.emitPayload && parsed.batch) {
-        error("research: --emit-payload is incompatible with --batch");
+        error(t("cli.research.emitPayloadIncompatibleBatch"));
         return 2;
     }
     if (parsed.batch) {
-        return runResearchBatch(parsed, cwd, log, warn, error, progress);
+        return runResearchBatch(parsed, cwd, locale, log, warn, error, progress, t);
     }
     if (parsed.status !== undefined) {
-        error("research: --status requires --batch");
+        error(t("cli.research.statusRequiresBatch"));
         return 2;
     }
     if (parsed.maxItems !== undefined) {
-        error("research: --max-items requires --batch");
+        error(t("cli.research.maxItemsRequiresBatch"));
         return 2;
     }
     if (parsed.filterTags !== undefined) {
-        error("research: --filter-tags requires --batch");
+        error(t("cli.research.filterTagsRequiresBatch"));
         return 2;
     }
     if (parsed.triageGroup !== undefined && !parsed.digest) {
-        error("research: --triage-group requires --digest");
+        error(t("cli.research.triageGroupRequiresDigest"));
         return 2;
     }
     if (parsed.itemIds.length === 0) {
-        error("research: missing <item-id>");
-        printHelp(error);
+        error(t("cli.research.missingItemId"));
+        printHelp(t, error);
         return 2;
     }
     if (!parsed.digest && parsed.itemIds.length > 1) {
-        error(`research: multiple <item-id> arguments require --digest (got ${parsed.itemIds.length}: ${parsed.itemIds.join(", ")})`);
+        error(t("cli.research.multipleRequireDigest", {
+            count: parsed.itemIds.length,
+            ids: parsed.itemIds.join(", "),
+        }));
         return 2;
     }
     if (parsed.digest && parsed.itemIds.length < 2) {
-        error(`research: --digest requires 2 or more <item-id> arguments (got ${parsed.itemIds.length})`);
+        error(t("cli.research.digestRequiresTwo", { count: parsed.itemIds.length }));
         return 2;
     }
-    const agentResult = await resolveAgent(cwd, parsed.agent, error);
+    const agentResult = await resolveAgent(cwd, parsed.agent, error, t);
     if ("exitCode" in agentResult)
         return agentResult.exitCode;
     const agent = agentResult.agent;
@@ -831,20 +857,20 @@ export async function runResearch(args, options = {}) {
     if (parsed.digest) {
         const result = await findItems(cwd, parsed.itemIds);
         if ("missing" in result) {
-            error(`research: item '${result.missing}' not found under items/`);
+            error(t("cli.research.itemNotFound", { id: result.missing }));
             return 1;
         }
         items = result.items;
         const dismissed = items.filter((i) => i.status === "dismissed");
         if (dismissed.length > 0) {
-            error(`research: cannot include dismissed items in a digest: ${dismissed.map((i) => i.id).join(", ")}`);
+            error(t("cli.research.digestDismissed", { ids: dismissed.map((i) => i.id).join(", ") }));
             return 1;
         }
     }
     else {
         const found = await findItem(cwd, parsed.itemIds[0]);
         if (!found) {
-            error(`research: item '${parsed.itemIds[0]}' not found under items/`);
+            error(t("cli.research.itemNotFound", { id: parsed.itemIds[0] }));
             return 1;
         }
         items = [found.item];
@@ -875,6 +901,7 @@ export async function runResearch(args, options = {}) {
             warn,
             error,
             progress,
+            t,
         });
     }
     return processResearchInvocation({
@@ -884,6 +911,7 @@ export async function runResearch(args, options = {}) {
         agent,
         templateId,
         template,
+        locale,
         now: new Date(),
         triageGroup: parsed.triageGroup,
         log,
@@ -895,6 +923,7 @@ export async function runResearch(args, options = {}) {
 export const researchCommand = {
     name: "research",
     summary: "Generate Markdown research reports from items via an AI agent",
+    summaryKey: "cli.summary.research",
     run: (args) => runResearch(args),
 };
 //# sourceMappingURL=research.js.map