@ozzylabs/feedradar 0.2.1 → 0.2.3

package/dist/i18n/messages/en.d.ts

@@ -0,0 +1,1049 @@
+/**
+ * English message catalog — the source of truth for the i18n layer (ADR-0021,
+ * epic #307 P2).
+ *
+ * `en` defines the canonical key set and value shapes; every other locale
+ * catalog (currently {@link import("./ja.js").ja}) is required by the
+ * {@link Messages} type to mirror these keys exactly. A value is either:
+ *
+ *   - a plain `string` (no interpolation), or
+ *   - a function `(params) => string` that receives a typed params object and
+ *     returns the rendered string.
+ *
+ * The function form is the single, unified interpolation scheme for this layer
+ * (no `{name}` placeholder string-replacement, no template engine, no new
+ * runtime dependency): parameters are ordinary typed function arguments, so a
+ * missing or misspelled param is a *compile* error, and `createTranslator`'s
+ * `t(key, params?)` signature can derive its param type straight from the
+ * catalog entry.
+ *
+ * Keys are namespaced by domain (`common.*`, `cli.*`) to keep future additions
+ * collision-free as later P3/P4/P5 issues add their own message families. This
+ * PR only fills the keys needed to prove the wiring on `src/cli/index.ts`'s
+ * global help / version / unknown-command paths.
+ */
+export declare const en: {
+    /** First line of `radar --help`: the product tagline. */
+    readonly "cli.help.tagline": "FeedRadar — Multi-agent CLI for blog/release feed research";
+    /** Usage synopsis line. */
+    readonly "cli.help.usage": "Usage: radar <command> [options]";
+    /** Section heading listing the subcommands. */
+    readonly "cli.help.commandsHeading": "Commands:";
+    /** Section heading listing the global options. */
+    readonly "cli.help.optionsHeading": "Options:";
+    /** `-h, --help` option description. */
+    readonly "cli.help.optionHelp": "Show this help";
+    /** `-v, --version` option description. */
+    readonly "cli.help.optionVersion": "Show version";
+    /** `--lang <en|ja>` option description. */
+    readonly "cli.help.optionLang": "UI language (overrides RADAR_LANG / config)";
+    /** stderr line when an unrecognized subcommand is given. */
+    readonly "cli.error.unknownCommand": ({ command }: {
+        command: string;
+    }) => string;
+    /** Follow-up hint pointing the user at `radar --help`. */
+    readonly "cli.error.unknownCommandHint": "Run 'radar --help' for available commands.";
+    /** "Loaded item: <id>" — single-item PRE phase marker. */
+    readonly "cli.progress.loadedItem": ({ id }: {
+        id: string;
+    }) => string;
+    /** "Loaded N items" — digest/batch PRE phase marker. */
+    readonly "cli.progress.loadedItems": ({ count }: {
+        count: number;
+    }) => string;
+    /** "Loaded template: <id>.md" — template-resolved phase marker. */
+    readonly "cli.progress.loadedTemplate": ({ templateId }: {
+        templateId: string;
+    }) => string;
+    /** "Spawning <agent>" — agent-spawn phase marker. */
+    readonly "cli.progress.spawning": ({ agent }: {
+        agent: string;
+    }) => string;
+    /** Spinner label while the agent runs. */
+    readonly "cli.progress.agentRunning": "Agent running";
+    /** "Agent completed (exit <code>)" — agent success line. */
+    readonly "cli.progress.agentCompleted": ({ exitCode }: {
+        exitCode: number;
+    }) => string;
+    /** Agent-failure spinner-fail label. */
+    readonly "cli.progress.agentFailed": "Agent failed";
+    /** "Frontmatter validated" — schema-check phase marker. */
+    readonly "cli.progress.frontmatterValidated": "Frontmatter validated";
+    /** "Status: <from> → <to>" — state-machine transition phase marker. */
+    readonly "cli.progress.statusTransition": ({ from, to }: {
+        from: string;
+        to: string;
+    }) => string;
+    /**
+     * "[<source-id>] <facet>Page <i>/<n>: <items> items fetched" — paginating-
+     * adapter (json-api) page phase marker. `facet` is a pre-built functional
+     * prefix (e.g. `year=2018 (15/23) `) or empty; the page / item counters are
+     * functional and stay verbatim. Only the "Page … items fetched" prose is
+     * translated.
+     */
+    readonly "cli.progress.watchPage": ({ sourceId, facet, page, pageTotal, items, }: {
+        sourceId: string;
+        facet: string;
+        page: number;
+        pageTotal: number;
+        items: number;
+    }) => string;
+    /** "[<source-id>] Completed: <total> total, <fresh> new" — per-source success line. */
+    readonly "cli.progress.watchSourceCompleted": ({ sourceId, total, fresh, }: {
+        sourceId: string;
+        total: number;
+        fresh: number;
+    }) => string;
+    /** "Still waiting for "<sel>"… [<mm:ss>]" — long html-js selector-wait reminder. */
+    readonly "cli.progress.stillWaiting": ({ selector, elapsed, }: {
+        selector: string;
+        elapsed: string;
+    }) => string;
+    /** "[<source-id>] Fetching…" — per-source start-of-fetch phase marker. */
+    readonly "cli.progress.watchFetching": ({ sourceId }: {
+        sourceId: string;
+    }) => string;
+    /** "kind: <kind>" — side-metric info shown alongside the Fetching phase. */
+    readonly "cli.progress.watchKindInfo": ({ kind }: {
+        kind: string;
+    }) => string;
+    /** "[<source-id>] Failed" — per-source fetch-failure phase label. */
+    readonly "cli.progress.watchFailed": ({ sourceId }: {
+        sourceId: string;
+    }) => string;
+    /** "Launching Chromium…" — html-js browser-launch phase marker. */
+    readonly "cli.progress.htmlJsLaunching": "Launching Chromium…";
+    /** "Navigating to <url>…" — html-js page-navigation phase marker. */
+    readonly "cli.progress.htmlJsNavigating": ({ url }: {
+        url: string;
+    }) => string;
+    /** "Waiting for selector "<sel>" (timeout: <ms>ms)…" — html-js selector-wait phase marker. */
+    readonly "cli.progress.htmlJsWaitingSelector": ({ selector, timeout, }: {
+        selector: string;
+        timeout: number;
+    }) => string;
+    /** "Capturing page content…" — html-js content-capture phase marker. */
+    readonly "cli.progress.htmlJsCapturing": "Capturing page content…";
+    /** "Closing browser…" — html-js browser-close phase marker. */
+    readonly "cli.progress.htmlJsClosing": "Closing browser…";
+    readonly "cli.summary.init": "Initialize a workspace (sources/items/state/research/templates)";
+    readonly "cli.summary.source": "Manage feed sources (add | list | recipes | remove | test)";
+    readonly "cli.summary.watch": "Fetch sources and produce filtered items (run)";
+    readonly "cli.summary.state": "Manage per-source watch state (prune)";
+    readonly "cli.summary.research": "Generate Markdown research reports from items via an AI agent";
+    readonly "cli.summary.triage": "LLM-based triage of detected items";
+    readonly "cli.summary.dismiss": "Mark detected items as dismissed (single id, multiple ids, or --batch)";
+    readonly "cli.summary.undismiss": "Reverse a dismiss (`dismissed → detected`)";
+    readonly "cli.summary.items": "Inspect items in the workspace (list | ...)";
+    readonly "cli.summary.review": "Cross-review existing research reports using a different AI agent";
+    readonly "cli.summary.update": "Refresh existing research reports against the latest items";
+    readonly "cli.summary.doctor": "Diagnose workspace, agent CLIs, and html-js Playwright install";
+    readonly "cli.summary.workflow": "Generate GitHub Actions workflows (generate <type>)";
+    readonly "cli.summary.routine": "Manage Claude Code Routines (generate <type> / fire <trig_id>)";
+    readonly "cli.research.help": ({ maxItems }: {
+        maxItems: number;
+    }) => string;
+    readonly "cli.review.help": ({ maxItems }: {
+        maxItems: number;
+    }) => string;
+    readonly "cli.update.help": "Usage:\n  radar update <research-id> [--agent <agent-id>] [--template <template-id>]\n  radar update <research-id> --emit-payload [--template <id>]\n  radar update --commit <path>\n\nArguments:\n  <research-id>         Research id (basename of research/<id>.md without .md)\n\nOptions:\n  --agent <agent-id>    claude-code | codex-cli | gemini-cli | copilot (default: claude-code)\n  --template <id>       Template id under templates/ (default: default)\n  --emit-payload        Host-agent mode: print the update payload to\n                        stdout and DO NOT spawn an agent. The interactive host\n                        session runs the SKILL procedure itself, then finalizes\n                        with `radar update --commit <path>`. Interactive/opt-in\n                        only — CI/headless must use the default spawn path.\n  --commit <path>       Host-agent mode: validate an externally-written\n                        v+1 report (under <cwd>/research/) against ResearchFrontmatter-\n                        Schema, assert the v+1 invariants against the `supersedes`\n                        predecessor, and leave items.yaml untouched.\n  --verbose             Stream the agent CLI's stdout/stderr in addition to phase markers.\n  --quiet               Suppress phase markers and spinner; print only the completion line.\n                        Equivalent to setting RADAR_NO_PROGRESS=1.\n\nGenerates research/<base>_v<n+1>.md from the supplied predecessor id,\nwriting `supersedes: <prev id>` into the new file's frontmatter. The\npredecessor file is never modified (immutable history), and\nthe linked items/<id>.yaml `status` is left untouched.";
+    readonly "cli.triage.runHelp": "Usage: radar triage [--dry-run | --apply | --interactive] [options]\n       radar triage --emit-payload [--source <id>] [options]\n       radar triage --commit <path>\n\nClassify `detected` items using the configured per-source triage policy.\n\nModes (mutually exclusive; default: --dry-run):\n  --dry-run            print proposed decisions to stdout (no disk writes)\n  --apply              write decisions to items/<id>.yaml + transition status\n  --interactive        --dry-run output → $EDITOR → confirm → apply\n\nOptions:\n  --source <id>            limit triage to a single source\n  --filter-tags <a,b>      matchedKeywords allow-list (comma-separated)\n  --triage-agent <id>      override policy.agent for this run\n  --policy <path>          override per-source policy with a YAML file\n  --max-items N            hard cap on items triaged in this run\n  --audit-log <path>       append JSONL audit records of every triage call\n  --emit-payload           Host-agent mode: print the triage payload to\n                           stdout and DO NOT spawn an agent. The interactive host\n                           session classifies the items itself, writes a decisions\n                           JSON, then finalizes with `radar triage --commit <path>`.\n                           Requires a single source group: pass --source unless only\n                           one source has detected items. Interactive/opt-in only —\n                           CI/headless must use the default spawn path.\n  --commit <path>          Host-agent mode: validate a host-written\n                           decisions JSON (under <cwd>/triage/) against the source's\n                           policy + detected items and apply the status transitions.\n  -v, --verbose            verbose progress output\n  -q, --quiet              suppress progress output entirely\n\nSources missing a `triagePolicy:` block are skipped with a warning.";
+    readonly "cli.triage.feedbackHelp": "Usage: radar triage feedback <item-id> --correct | --wrong [--reason <text>]\n\nRecord human feedback on a prior triage decision.\nFeedback is appended to items/<id>.yaml > triage.feedback, used by\n`radar triage stats` (#242) for policy tuning.\n\nOptions:\n  --correct            mark the prior triage decision as correct\n  --wrong              mark the prior triage decision as wrong\n  --reason <text>      free-form rationale (recommended for --wrong)";
+    readonly "cli.triage.statsHelp": "Usage: radar triage stats [--since <duration>] [--source <id>] [--json]\n\nAggregate triage decisions and human feedback.\nUse after running `radar triage --apply` for some weeks; the output\nhighlights precision / recall drift and suggests `triagePolicy.rules:`\ntweaks. See docs/user-guide.md `policy tuning workflow` for the\nrecommended monthly loop.\n\nOptions:\n  --since <duration>   only count items triaged within the cutoff (e.g. 30d, 24h)\n  --source <id>        limit stats to a single source (default: all sources)\n  --json               emit machine-readable JSON instead of the text report";
+    readonly "cli.triage.help": "Usage: radar triage <subcommand|--apply|--dry-run|--interactive> [...]\n\nSubcommands:\n  feedback <item-id> --correct | --wrong [--reason <text>]\n  stats [--since <duration>] [--source <id>] [--json]\n\nRun modes (when no subcommand given):\n  --dry-run            print proposed decisions\n  --apply              write decisions to items/<id>.yaml\n  --interactive        edit decisions in $EDITOR before applying\n\nRun `radar triage --help` for the full option list.";
+    readonly "cli.dismiss.help": ({ maxItems }: {
+        maxItems: number;
+    }) => string;
+    readonly "cli.undismiss.help": "Usage: radar undismiss <item-id> [--force]\n\nArguments:\n  <item-id>             Item id (matches items/<sourceId>/<item-id>.yaml)\n\nOptions:\n  --force, -f           Required when reversing a human-origin dismiss\n\nReverses `dismissed → detected`.\nTriage-origin dismisses revert silently; human-origin dismisses require --force.\n\nInverse of `radar dismiss`.";
+    readonly "cli.items.listHelp": "Usage: radar items list [filters] [output options]\n\nFilters:\n  --status <status>        detected | triaged_research | triaged_digest |\n                           triaged_unsure | researched | reviewed | dismissed\n  --source <id>            limit to one source\n  --triage-group <name>    items whose triage.group == <name>\n                           (used by digest workflow)\n  --since <duration>       drop items older than the cutoff (e.g. 7d, 24h)\n  --limit N                cap result count\n\nOutput options:\n  --json                   emit JSON array (one object per item)\n  --field <expr>           emit one item field per row (e.g. id, sourceId,\n                           triage.decision). Supports nested dot paths.";
+    readonly "cli.items.help": "Usage: radar items <list> [...]\n\nSubcommands:\n  list [filters]           List items matching the supplied filters";
+    readonly "cli.watch.help": "Usage: radar watch <run> [options]\n\nSubcommands:\n  run [--source <id>] [--bootstrap | --backfill [--max-pages N]]\n                  Fetch sources and produce items\n\nOptions for run:\n  --source <id>     Limit the run to a single source id\n  --bootstrap       Seed lastSeenIds without emitting items (suppress initial noise)\n  --backfill        Fetch all available history pages and emit items for each.\n                    Supported fully by kind: json-api / github-releases / npm-registry.\n                    Other kinds (rss / html / html-js) only return their current page.\n  --max-pages N     Override pagination.maxPages cap (requires --backfill).\n                    Applies to INNER pagination only — facet sweep\n                    always walks every facet value regardless of this flag.\n  -v, --verbose     Enable progress-reporter raw() pass-through (adapter stdout).\n  -q, --quiet       Suppress the per-source progress reporter (legacy 1-line log\n                    remains). RADAR_NO_PROGRESS=1 has the same effect.";
+    readonly "cli.doctor.help": "Usage: radar doctor [--no-proxy-check]\n\nDiagnose the workspace and report dependency / configuration health.\n\nChecks performed:\n  - Workspace directories (sources/, items/, state/, research/, templates/)\n  - radar.config.yaml schema validity\n  - Agent CLI availability (claude / codex / gemini / copilot)\n  - Playwright + Chromium install (only if html-js sources configured)\n  - Proxy env vars (HTTPS_PROXY / HTTP_PROXY / ALL_PROXY) with credential masking\n  - NODE_USE_ENV_PROXY status (engaged when radar self-respawned for proxy)\n  - NODE_EXTRA_CA_CERTS status (required for TLS-intercepting proxies)\n  - Live proxy healthcheck (HTTPS request to api.github.com)\n\nOptions:\n  --no-proxy-check  Skip the live proxy healthcheck (offline-friendly)\n\nExit codes:\n  0  all ok (warnings may appear, but no errors)\n  1  one or more error-level checks failed";
+    readonly "cli.source.addHelp": "Usage: radar source add <id> --kind <kind> --url <url> [options]\n       radar source add <id> --recipe <name> [overrides]\n\nOptions:\n  --kind <kind>            rss | html | html-js | github-releases | npm-registry | json-feed | json-api\n  --url <url>              fetch target URL\n  --recipe <name>          apply a bundled recipe (see `radar source recipes`).\n                           Mutually exclusive with --kind / --url / --selector-* /\n                           --pagination-*; --name / --tags / --keywords /\n                           --exclude-keywords still override the recipe defaults.\n  --name <name>            display name (defaults to <id>)\n  --tags <a,b>             comma-separated tags\n  --keywords <a,b>         comma-separated include keywords\n                           (required for useful output — empty = match nothing)\n  --exclude-keywords <a,b> comma-separated exclude keywords\n  --selector-<field> <css> CSS selector for kind=html / html-js (required: item, title, link)\n                           optional: summary, publishedAt, body, tags\n                           For kind=html-js, selectors evaluate against the post-JS DOM.\n                           The `js:` block (waitFor / timeout / userAgent) cannot be set\n                           via flags; edit sources/<id>.yaml after add.\n\n  For kind=json-api:\n    --pagination-strategy <s>  page | offset | cursor | link-header | token | none (default: page)\n    --pagination-param <name>  query param name for the page/offset/cursor value\n    --pagination-start N       initial page/offset value (default: 0)\n    --page-size N              items per page\n    --page-size-param <name>   query param name for the page-size value\n    --max-pages N              hard cap on pages traversed (default: 20)\n    --next-cursor-path <jp>    JSONPath-lite to the next-cursor value (cursor/token strategy)\n    --total-path <jp>          JSONPath-lite to the total-count value (backfill early-stop hint)\n\n  Selector fields (`jsonSelectors.*`) for kind=json-api cannot be set via flags;\n  the schema has a default fallback chain (items / title / link / publishedAt / summary),\n  so simple APIs work without selectors. Edit sources/<id>.yaml directly when explicit\n  selectors are needed (nested fields, non-standard envelopes).\n\n  Facet sweep (e.g. year-by-year sweep) cannot be configured via flags;\n  and bundle the year sweep through `--recipe aws-whats-new`. Recipe-only structural field.";
+    readonly "cli.source.listHelp": "Usage: radar source list [--enabled-only] [-v|--verbose]\n\nLists sources/*.yaml in tabular form: id / kind / url / tags.\n\nOptions:\n  --enabled-only   Reserved for forward compatibility (currently a no-op).\n  -v, --verbose    Print a detailed block per source including keywords,\n                   trustLevel, and lastFetchedAt (from state/<id>.yaml).";
+    readonly "cli.source.removeHelp": "Usage: radar source remove <id>\n\nDeletes sources/<id>.yaml. state/<id>.yaml and items/ are preserved.";
+    readonly "cli.source.testHelp": "Usage: radar source test <id> [--limit N] [--show-content]\n\nDry-run a single source: fetch, filter, and print matched items.\nstate/ and items/ are not touched (no persistence). Useful for tuning\nkeywords when adding a new source.\n\nFor kind=json-api, `source test` fetches PAGE 0 ONLY.\nPagination is NOT walked even when the recipe declares multiple pages —\n`--limit N` caps how many matched items are PRINTED, it does not change\nthe page budget. Use `radar watch run --backfill` for full-history ingest.\nPage 0's `Link` header / `nextCursor` extraction is surfaced via\n`--show-content` for pagination tuning without state mutation.\n\nFor facet-sweep recipes, `source test` probes a SINGLE\nfacet value: range facets use the upper bound (latest year), enum facets\nuse the first listed value. A warning names which value was tested so\nkeyword tuning is not silently scoped to one slice. Run `radar watch run\n--backfill` to sweep every facet value.\n\nOptions:\n  --limit N        Maximum number of matched items to print (default 10)\n  --show-content   Also print the first 200 chars of each item's body, plus\n                   (kind=json-api) the selector adoption table and pagination\n                   preview (would-be next URL / Link header / nextCursor).\n  -v, --verbose    Enable progress-reporter raw() pass-through (adapter stdout).\n                   Most useful with kind=html-js (Playwright phase markers).\n  -q, --quiet      Suppress the progress reporter entirely. RADAR_NO_PROGRESS=1\n                   has the same effect.";
+    readonly "cli.source.recipesHelp": "Usage: radar source recipes\n\nList bundled recipes (recipes/*.yaml in the radar package).\nEach recipe can be applied via:\n  radar source add <id> --recipe <name> [--keywords <kw>] [--tags <t>] [--name <display>]\n\nBundled recipes ship with the radar npm package; user-authored recipes are\nnot yet supported. To add a new bundled recipe, contribute a YAML to the\nradar repo's recipes/ directory.";
+    readonly "cli.source.help": "Usage: radar source <add|list|recipes|remove|test> [...]\n\nSubcommands:\n  add <id> --kind <kind> --url <url> [...]\n  add <id> --recipe <name> [--keywords <kw>] [--tags <t>] [--name <display>]\n  list [--enabled-only]\n  recipes\n  remove <id>\n  test <id> [--limit N] [--show-content]";
+    readonly "cli.workflow.help": "Usage: radar workflow <subcommand> [...]\n\nSubcommands:\n  generate <type>  Generate a GitHub Actions workflow YAML\n                   Types: watch | combined | combined-with-triage\n\nRun `radar workflow generate <type> --help` for type-specific options.";
+    readonly "cli.workflow.generateHelp": "Usage: radar workflow generate <type> [options]\n\nTypes:\n  watch                  Periodic `radar watch run` (cron + state commit with rebase retry)\n  combined               Periodic `radar watch run` -> auto research --batch with hard cap\n  combined-with-triage   `watch run` -> `triage --apply` -> `research --batch` -> per-group `research --digest` -> `review --batch` in one job\n\nRun `radar workflow generate <type> --help` for type-specific options.";
+    readonly "cli.workflow.generateWatchHelp": "Usage: radar workflow generate watch [options]\n\nGenerates a GitHub Actions workflow that runs `radar watch run` on a cron schedule.\nThe generated workflow includes git pull --rebase retry logic to mitigate push\nconflicts with other concurrent workflows.\n\nOptions:\n  --cron <expression>   5-field cron expression (default: \"0 0 * * *\")\n  --output <path>       Output file under .github/workflows/\n                        (default: .github/workflows/feedradar-watch.yaml)\n  --agent <name>        claude-code | codex-cli | gemini-cli | copilot (default: claude-code)\n                        Determines which secret name the workflow references.\n  --force, -f           Overwrite existing output file\n  --lang <en|ja>        Language for the generated YAML's comments / step names\n                        (default: en; also honors RADAR_LANG and config.locale)\n\nRequired secrets (Settings → Secrets and variables → Actions):\n  ANTHROPIC_API_KEY    when --agent claude-code (default)\n  OPENAI_API_KEY       when --agent codex-cli\n  GEMINI_API_KEY       when --agent gemini-cli\n  GITHUB_TOKEN         auto-provisioned for --agent copilot (no setup needed)";
+    readonly "cli.workflow.generateCombinedHelp": ({ maxItems }: {
+        maxItems: number;
+    }) => string;
+    readonly "cli.workflow.generateCombinedWithTriageHelp": ({ watchCron, output, maxItems, }: {
+        watchCron: string;
+        output: string;
+        maxItems: number;
+    }) => string;
+    readonly "cli.routine.help": "Usage: radar routine <subcommand> [...]\n\nSubcommands:\n  generate <type>  Generate a Claude Code Routine YAML (.claude/routines/)\n                   Types: watch | pipeline\n  fire <trig_id>   Trigger a registered routine from the outside (/fire API)\n\nRun `radar routine <subcommand> --help` for subcommand-specific options.";
+    readonly "cli.routine.generateHelp": "Usage: radar routine generate <type> [options]\n\nTypes:\n  watch     Periodic `radar watch run` self-session routine; commits items/state to a claude/* branch\n  pipeline  Full watch -> triage -> research -> review self-session routine, one item at a time\n\nRun `radar routine generate <type> --help` for type-specific options.";
+    readonly "cli.routine.generateWatchHelp": ({ models }: {
+        models: string;
+    }) => string;
+    readonly "cli.routine.generatePipelineHelp": ({ models, maxItems, }: {
+        models: string;
+        maxItems: number;
+    }) => string;
+    readonly "cli.routine.fireHelp": ({ tokenEnv }: {
+        tokenEnv: string;
+    }) => string;
+    readonly "cli.dismiss.batchIncompatiblePositional": ({ count }: {
+        count: number;
+    }) => string;
+    readonly "cli.dismiss.invalidStatus": ({ status, allowed }: {
+        status: string;
+        allowed: string;
+    }) => string;
+    readonly "cli.dismiss.statusRequiresBatch": "dismiss: --status requires --batch";
+    readonly "cli.dismiss.maxItemsRequiresBatch": "dismiss: --max-items requires --batch";
+    readonly "cli.dismiss.filterTagsRequiresBatch": "dismiss: --filter-tags requires --batch";
+    readonly "cli.dismiss.invalidMaxItemsInteger": ({ raw }: {
+        raw: string;
+    }) => string;
+    readonly "cli.dismiss.invalidMaxItemsPositive": ({ raw }: {
+        raw: string;
+    }) => string;
+    readonly "cli.dismiss.missingItemId": "dismiss: missing <item-id>";
+    readonly "cli.dismiss.itemNotFound": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.dismiss.itemWrongStatus": ({ id, status, allowed, nextStatuses, }: {
+        id: string;
+        status: string;
+        allowed: string;
+        nextStatuses: string;
+    }) => string;
+    readonly "cli.dismiss.failedUpdate": ({ reason }: {
+        reason: string;
+    }) => string;
+    readonly "cli.dismiss.transitioned": ({ sourceId, id }: {
+        sourceId: string;
+        id: string;
+    }) => string;
+    readonly "cli.dismiss.noItemsMatched": ({ status, tags }: {
+        status: string;
+        tags: string;
+    }) => string;
+    readonly "cli.dismiss.capReached": ({ maxItems, dropped, matched, }: {
+        maxItems: number;
+        dropped: number;
+        matched: number;
+    }) => string;
+    readonly "cli.dismiss.batchWillProcess": ({ count, status, tags, cap, }: {
+        count: number;
+        status: string;
+        tags: string;
+        cap: number;
+    }) => string;
+    readonly "cli.dismiss.batchCompleted": ({ count }: {
+        count: number;
+    }) => string;
+    readonly "cli.undismiss.missingItemId": "undismiss: missing <item-id>";
+    readonly "cli.undismiss.itemsDirNotFound": "undismiss: items/ not found (run `radar init`)";
+    readonly "cli.undismiss.itemNotFound": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.undismiss.notDismissed": ({ id, status }: {
+        id: string;
+        status: string;
+    }) => string;
+    readonly "cli.undismiss.forbiddenTransition": "undismiss: state machine forbids 'dismissed → detected' (internal error)";
+    readonly "cli.undismiss.humanOriginRequiresForce": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.undismiss.failedUpdate": ({ reason }: {
+        reason: string;
+    }) => string;
+    readonly "cli.undismiss.revertedHumanOrigin": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.undismiss.transitioned": ({ sourceId, id }: {
+        sourceId: string;
+        id: string;
+    }) => string;
+    readonly "cli.doctor.workspaceDirExists": ({ dir }: {
+        dir: string;
+    }) => string;
+    readonly "cli.doctor.workspaceDirMissing": ({ dir }: {
+        dir: string;
+    }) => string;
+    readonly "cli.doctor.configValid": "radar.config.yaml valid (or absent — defaults apply)";
+    readonly "cli.doctor.configInvalid": ({ reason }: {
+        reason: string;
+    }) => string;
+    readonly "cli.doctor.agentFound": ({ agent, binary, path, }: {
+        agent: string;
+        binary: string;
+        path: string;
+    }) => string;
+    readonly "cli.doctor.agentMissing": ({ agent, binary }: {
+        agent: string;
+        binary: string;
+    }) => string;
+    readonly "cli.doctor.playwrightNotRequired": "playwright: not required (no html-js sources configured)";
+    readonly "cli.doctor.playwrightOk": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.doctor.playwrightModuleMissing": ({ sources, hint, }: {
+        sources: string;
+        hint: string;
+    }) => string;
+    readonly "cli.doctor.playwrightChromiumMissing": ({ path, sources, hint, }: {
+        path: string;
+        sources: string;
+        hint: string;
+    }) => string;
+    readonly "cli.doctor.proxyEnvAllProxyOnly": ({ source, masked, }: {
+        source: string;
+        masked: string;
+    }) => string;
+    readonly "cli.doctor.proxyEnvDetected": ({ source, masked }: {
+        source: string;
+        masked: string;
+    }) => string;
+    readonly "cli.doctor.proxyEnvNone": "proxy: no proxy env var set (HTTPS_PROXY / HTTP_PROXY / ALL_PROXY)";
+    readonly "cli.doctor.proxyActive": "proxy: NODE_USE_ENV_PROXY active (auto-applied by radar)";
+    readonly "cli.doctor.proxyActiveMissing": "proxy: NODE_USE_ENV_PROXY not set; if fetch ignores HTTPS_PROXY, re-run radar via the bin (not direct import)";
+    readonly "cli.doctor.proxyActiveNotRequired": "proxy: NODE_USE_ENV_PROXY not required (no proxy detected)";
+    readonly "cli.doctor.tlsCaSet": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.doctor.tlsCaUnset": "tls: NODE_EXTRA_CA_CERTS not set (TLS-intercepting proxies may fail)";
+    readonly "cli.doctor.healthcheckSkippedFlag": "proxy healthcheck: skipped (--no-proxy-check)";
+    readonly "cli.doctor.healthcheckSkippedNoProxy": "proxy healthcheck: skipped (no proxy detected)";
+    readonly "cli.doctor.healthcheck407": ({ url }: {
+        url: string;
+    }) => string;
+    readonly "cli.doctor.healthcheckOk": ({ status, statusText, elapsed, }: {
+        status: number;
+        statusText: string;
+        elapsed: number;
+    }) => string;
+    readonly "cli.doctor.healthcheckOther": ({ status, statusText, elapsed, }: {
+        status: number;
+        statusText: string;
+        elapsed: number;
+    }) => string;
+    readonly "cli.doctor.healthcheckTimeout": ({ elapsed }: {
+        elapsed: number;
+    }) => string;
+    readonly "cli.doctor.healthcheckTls": ({ code }: {
+        code: string;
+    }) => string;
+    readonly "cli.doctor.healthcheckRefused": "proxy healthcheck: connection refused. Verify the proxy host:port in $HTTPS_PROXY is reachable.";
+    readonly "cli.doctor.healthcheckDns": ({ code }: {
+        code: string;
+    }) => string;
+    readonly "cli.doctor.healthcheckResetTimeout": ({ code }: {
+        code: string;
+    }) => string;
+    readonly "cli.doctor.healthcheckFailed": ({ reason }: {
+        reason: string;
+    }) => string;
+    readonly "cli.doctor.summary": ({ ok, warn, error, }: {
+        ok: number;
+        warn: number;
+        error: number;
+    }) => string;
+    readonly "cli.init.workspaceReady": ({ cwd }: {
+        cwd: string;
+    }) => string;
+    readonly "cli.init.directoriesCreated": ({ dirs }: {
+        dirs: string;
+    }) => string;
+    readonly "cli.init.skillsCopied": ({ files }: {
+        files: string;
+    }) => string;
+    readonly "cli.init.filesSkipped": ({ files }: {
+        files: string;
+    }) => string;
+    readonly "cli.init.nextSteps": "init: next steps — read FEEDRADAR.md for natural-language and slash usage.";
+    readonly "cli.items.unknownSubcommand": ({ sub }: {
+        sub: string;
+    }) => string;
+    readonly "cli.items.invalidStatus": ({ status, allowed }: {
+        status: string;
+        allowed: string;
+    }) => string;
+    readonly "cli.items.invalidSince": ({ since }: {
+        since: string;
+    }) => string;
+    readonly "cli.items.noItemsDir": "items list: no items/ directory (run `radar init` first)";
+    readonly "cli.items.noMatch": "items list: no items match the filter";
+    readonly "cli.watch.bootstrapBackfillExclusive": "--bootstrap and --backfill are mutually exclusive";
+    readonly "cli.watch.maxPagesRequiresBackfill": "--max-pages requires --backfill";
+    readonly "cli.watch.verboseQuietExclusive": "--verbose and --quiet are mutually exclusive";
+    readonly "cli.watch.unknownSubcommand": ({ sub }: {
+        sub: string;
+    }) => string;
+    readonly "cli.watch.bootstrapComplete": ({ sources }: {
+        sources: number;
+    }) => string;
+    readonly "cli.watch.backfillComplete": ({ total, sources }: {
+        total: number;
+        sources: number;
+    }) => string;
+    readonly "cli.watch.runComplete": ({ total, sources }: {
+        total: number;
+        sources: number;
+    }) => string;
+    readonly "cli.config.schemaViolation": ({ file, issues }: {
+        file: string;
+        issues: string;
+    }) => string;
+    readonly "cli.config.failedRead": ({ file, reason }: {
+        file: string;
+        reason: string;
+    }) => string;
+    readonly "cli.config.failedParse": ({ file, reason }: {
+        file: string;
+        reason: string;
+    }) => string;
+    readonly "cli.agent.invalid": ({ cmd, agent }: {
+        cmd: string;
+        agent: string;
+    }) => string;
+    readonly "cli.research.batchIncompatiblePositional": ({ count }: {
+        count: number;
+    }) => string;
+    readonly "cli.research.batchIncompatibleDigest": "research: --batch is incompatible with --digest";
+    readonly "cli.research.batchIncompatibleTriageGroup": "research: --batch is incompatible with --triage-group";
+    readonly "cli.research.invalidStatus": ({ status, allowed, }: {
+        status: string;
+        allowed: string;
+    }) => string;
+    readonly "cli.research.invalidMaxItemsInteger": ({ raw }: {
+        raw: string;
+    }) => string;
+    readonly "cli.research.invalidMaxItemsPositive": ({ raw }: {
+        raw: string;
+    }) => string;
+    readonly "cli.research.commitIncompatibleBatch": "research: --commit is incompatible with --batch";
+    readonly "cli.research.commitIncompatibleDigest": "research: --commit is incompatible with --digest";
+    readonly "cli.research.commitIncompatibleEmitPayload": "research: --commit is incompatible with --emit-payload";
+    readonly "cli.research.commitIncompatibleTriageGroup": "research: --commit is incompatible with --triage-group";
+    readonly "cli.research.commitTakesPath": ({ count, ids }: {
+        count: number;
+        ids: string;
+    }) => string;
+    readonly "cli.research.emitPayloadIncompatibleBatch": "research: --emit-payload is incompatible with --batch";
+    readonly "cli.research.statusRequiresBatch": "research: --status requires --batch";
+    readonly "cli.research.maxItemsRequiresBatch": "research: --max-items requires --batch";
+    readonly "cli.research.filterTagsRequiresBatch": "research: --filter-tags requires --batch";
+    readonly "cli.research.triageGroupRequiresDigest": "research: --triage-group requires --digest";
+    readonly "cli.research.missingItemId": "research: missing <item-id>";
+    readonly "cli.research.multipleRequireDigest": ({ count, ids }: {
+        count: number;
+        ids: string;
+    }) => string;
+    readonly "cli.research.digestRequiresTwo": ({ count }: {
+        count: number;
+    }) => string;
+    readonly "cli.research.itemNotFound": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.research.digestDismissed": ({ ids }: {
+        ids: string;
+    }) => string;
+    readonly "cli.research.alreadyExists": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.research.noItemsMatched": ({ status, tags }: {
+        status: string;
+        tags: string;
+    }) => string;
+    readonly "cli.research.capReached": ({ maxItems, dropped, matched, }: {
+        maxItems: number;
+        dropped: number;
+        matched: number;
+    }) => string;
+    readonly "cli.research.batchWillProcess": ({ count, status, tags, agent, cap, }: {
+        count: number;
+        status: string;
+        tags: string;
+        agent: string;
+        cap: number;
+    }) => string;
+    readonly "cli.research.batchHalted": ({ id, exitCode }: {
+        id: string;
+        exitCode: number;
+    }) => string;
+    readonly "cli.research.batchCompleted": ({ count }: {
+        count: number;
+    }) => string;
+    readonly "cli.research.wrote": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.research.transitioned": ({ sourceId, id }: {
+        sourceId: string;
+        id: string;
+    }) => string;
+    readonly "cli.review.batchIncompatiblePositional": ({ researchId }: {
+        researchId: string;
+    }) => string;
+    readonly "cli.review.invalidStatus": ({ status, allowed }: {
+        status: string;
+        allowed: string;
+    }) => string;
+    readonly "cli.review.invalidMaxItemsInteger": ({ raw }: {
+        raw: string;
+    }) => string;
+    readonly "cli.review.invalidMaxItemsPositive": ({ raw }: {
+        raw: string;
+    }) => string;
+    readonly "cli.review.commitIncompatibleBatch": "review: --commit is incompatible with --batch";
+    readonly "cli.review.commitIncompatibleEmitPayload": "review: --commit is incompatible with --emit-payload";
+    readonly "cli.review.commitTakesPath": ({ researchId }: {
+        researchId: string;
+    }) => string;
+    readonly "cli.review.emitPayloadIncompatibleBatch": "review: --emit-payload is incompatible with --batch";
+    readonly "cli.review.statusRequiresBatch": "review: --status requires --batch";
+    readonly "cli.review.maxItemsRequiresBatch": "review: --max-items requires --batch";
+    readonly "cli.review.filterTagsRequiresBatch": "review: --filter-tags requires --batch";
+    readonly "cli.review.missingResearchId": "review: missing <research-id>";
+    readonly "cli.review.fileNotFound": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.review.batchFoundNone": "review: --batch found no un-reviewed research/*.md files";
+    readonly "cli.review.batchMatchedZero": ({ status, tags }: {
+        status: string;
+        tags: string;
+    }) => string;
+    readonly "cli.review.capReached": ({ maxItems, dropped, matched, }: {
+        maxItems: number;
+        dropped: number;
+        matched: number;
+    }) => string;
+    readonly "cli.review.batchWillProcess": ({ count, status, tags, agent, cap, }: {
+        count: number;
+        status: string;
+        tags: string;
+        agent: string;
+        cap: number;
+    }) => string;
+    readonly "cli.review.batchHalted": ({ researchId, exitCode, }: {
+        researchId: string;
+        exitCode: number;
+    }) => string;
+    readonly "cli.review.batchCompleted": ({ count }: {
+        count: number;
+    }) => string;
+    readonly "cli.review.commitNotStamped": ({ id, reviewedAt, reviewedBy, }: {
+        id: string;
+        reviewedAt: string;
+        reviewedBy: string;
+    }) => string;
+    readonly "cli.review.alreadyReviewed": ({ id, reviewedAt, reviewedBy, }: {
+        id: string;
+        reviewedAt: string;
+        reviewedBy: string;
+    }) => string;
+    readonly "cli.review.wroteCommit": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.review.stamped": ({ path, reviewedAt, reviewedBy, }: {
+        path: string;
+        reviewedAt: string;
+        reviewedBy: string;
+    }) => string;
+    readonly "cli.review.transitioned": ({ sourceId, id }: {
+        sourceId: string;
+        id: string;
+    }) => string;
+    readonly "cli.update.commitIncompatibleEmitPayload": "update: --commit is incompatible with --emit-payload";
+    readonly "cli.update.commitTakesPath": ({ researchId }: {
+        researchId: string;
+    }) => string;
+    readonly "cli.update.missingResearchId": "update: missing <research-id>";
+    readonly "cli.update.fileNotFound": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.update.alreadyExists": ({ path, version }: {
+        path: string;
+        version: number;
+    }) => string;
+    readonly "cli.update.commitSupersedesNull": "update: --commit report has `supersedes: null`. update finalizes a v+1 (use `radar research --commit` for a v1).";
+    readonly "cli.update.wrote": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.update.supersedes": ({ prevId }: {
+        prevId: string;
+    }) => string;
+    readonly "cli.source.missingId": ({ sub }: {
+        sub: string;
+    }) => string;
+    readonly "cli.source.invalidId": ({ sub, id }: {
+        sub: string;
+        id: string;
+    }) => string;
+    readonly "cli.source.kindRequired": "source add: --kind is required";
+    readonly "cli.source.urlRequired": "source add: --url is required";
+    readonly "cli.source.invalidKind": ({ kind }: {
+        kind: string;
+    }) => string;
+    readonly "cli.source.paginationOnlyJsonApi": ({ kind }: {
+        kind: string;
+    }) => string;
+    readonly "cli.source.validationFailed": "source add: validation failed";
+    readonly "cli.source.recipeForbiddenFlags": ({ recipe, flags, }: {
+        recipe: string;
+        flags: string;
+    }) => string;
+    readonly "cli.source.recipeInvalidSource": ({ recipe }: {
+        recipe: string;
+    }) => string;
+    readonly "cli.source.alreadyExists": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.source.created": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.source.createdFromRecipe": ({ id, recipe }: {
+        id: string;
+        recipe: string;
+    }) => string;
+    readonly "cli.source.noKeywordsWarn": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.source.noKeywordsWarnRecipe": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.source.listNoDir": "source list: no sources directory (run `radar init` first)";
+    readonly "cli.source.listNoSources": "source list: no sources defined (use `radar source add ...`)";
+    readonly "cli.source.removeNotFound": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.source.deleted": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.source.testNotFound": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.source.recipesNone": "source recipes: no recipes bundled (recipes/ is empty or absent)";
+    readonly "cli.source.unknownSubcommand": ({ sub }: {
+        sub: string;
+    }) => string;
+    readonly "cli.triage.modesExclusive": "--dry-run / --apply / --interactive are mutually exclusive";
+    readonly "cli.triage.verboseQuietExclusive": "--verbose and --quiet are mutually exclusive";
+    readonly "cli.triage.commitIncompatibleModes": "triage: --commit is incompatible with --dry-run / --apply / --interactive";
+    readonly "cli.triage.commitIncompatibleEmitPayload": "triage: --commit is incompatible with --emit-payload";
+    readonly "cli.triage.emitPayloadIncompatibleModes": "triage: --emit-payload is incompatible with --dry-run / --apply / --interactive";
+    readonly "cli.triage.emitPayloadSingleSource": ({ count, sources, }: {
+        count: number;
+        sources: string;
+    }) => string;
+    readonly "cli.triage.invalidTriageAgent": ({ agent }: {
+        agent: string;
+    }) => string;
+    readonly "cli.triage.noSourcesDir": "triage: no sources/ directory (run `radar init` first)";
+    readonly "cli.triage.noSourcesDefined": "triage: no sources defined; nothing to triage";
+    readonly "cli.triage.noItemsDir": "triage: no items/ directory; nothing to triage";
+    readonly "cli.triage.noDetectedMatch": "triage: no detected items match the filter (nothing to do)";
+    readonly "cli.triage.maxItemsExceeded": ({ detected, maxItems, }: {
+        detected: number;
+        maxItems: number;
+    }) => string;
+    readonly "cli.triage.skippingNoPolicy": ({ count, sourceId, }: {
+        count: number;
+        sourceId: string;
+    }) => string;
+    readonly "cli.triage.noItemsTriaged": "triage: no items were triaged (all sources skipped)";
+    readonly "cli.triage.dryRunNoChanges": "triage: dry-run — no changes written";
+    readonly "cli.triage.abortedByUser": "triage: aborted by user";
+    readonly "cli.triage.applied": ({ count }: {
+        count: number;
+    }) => string;
+    readonly "cli.triage.committed": ({ count, sourceId }: {
+        count: number;
+        sourceId: string;
+    }) => string;
+    readonly "cli.triage.decisionsFileNotFound": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.triage.unknownSource": ({ sourceId }: {
+        sourceId: string;
+    }) => string;
+    readonly "cli.triage.sourceNoPolicy": ({ sourceId }: {
+        sourceId: string;
+    }) => string;
+    readonly "cli.triage.noItemsDirCommit": "triage: no items/ directory; nothing to commit";
+    readonly "cli.triage.noDetectedForSource": ({ sourceId }: {
+        sourceId: string;
+    }) => string;
+    readonly "cli.triage.invalidDecisionsAgent": ({ agent }: {
+        agent: string;
+    }) => string;
+    readonly "cli.triage.feedbackMissingItemId": "triage feedback: missing <item-id>";
+    readonly "cli.triage.feedbackModesExclusive": "triage feedback: --correct and --wrong are mutually exclusive";
+    readonly "cli.triage.feedbackModeRequired": "triage feedback: one of --correct | --wrong is required";
+    readonly "cli.triage.feedbackItemsDirNotFound": "triage feedback: items/ not found (run `radar init`)";
+    readonly "cli.triage.feedbackItemNotFound": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.triage.feedbackNoPriorDecision": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.triage.feedbackRecorded": ({ sourceId, id, verdict, }: {
+        sourceId: string;
+        id: string;
+        verdict: string;
+    }) => string;
+    readonly "cli.triage.statsInvalidSince": ({ since }: {
+        since: string;
+    }) => string;
+    readonly "cli.triage.statsNoItemsDir": "triage stats: no items/ directory (run `radar init` first)";
+    readonly "cli.triage.statsNoMatch": "triage stats: no triaged items match the filter (nothing to report)";
+    readonly "cli.init.help": "Usage: radar init [--lang <en|ja>] [--force] [--with-routines] [--with-actions]\n                          [--no-claude-skills] [--no-gemini-commands]\n                          [--no-agents-md] [--no-claude-md] [--no-templates]\n                          [--no-feedradar-md]\n\nCreates the workspace directories and copies bundled skills:\n  - Engine SKILLs (SSoT): .agents/skills/{research,review,update}/SKILL.md\n  - Claude Code slash-command wrappers: .claude/skills/{research,review,update,dismiss}/SKILL.md\n  - Gemini CLI slash commands: .gemini/commands/{research,review,update,dismiss}.toml\n  - Agent-agnostic instructions: AGENTS.md (auto-read by Codex / Gemini / Copilot)\n  - Claude Code workspace instructions: CLAUDE.md (imports @AGENTS.md so Claude reads it)\n  - Starter report templates: templates/default.md (single item) and templates/digest.md (multi-item digest)\n  - Human-facing workspace guide: FEEDRADAR.md (natural-language / slash usage)\n\nOptions:\n  --lang <en|ja>         Language for generated report templates and workspace docs\n                         (default: en; also honors RADAR_LANG; persisted to radar.config.yaml)\n  --force                Overwrite existing files\n  --with-routines        Generate .claude/routines/watch-daily.yaml (Claude Routines scaffold)\n  --with-actions         Generate .github/workflows/watch.yaml (GitHub Actions cron scaffold)\n  --no-claude-skills     Skip writing slash-command wrappers to .claude/skills/\n                         (useful if @ozzylabs/skills Renovate preset manages that directory)\n  --no-gemini-commands   Skip writing Gemini CLI slash commands to .gemini/commands/\n                         (engine SKILLs still serve interactive Gemini via dual-mode)\n  --no-agents-md         Skip writing AGENTS.md at the workspace root\n                         (useful if the workspace already has its own AGENTS.md;\n                          implies --no-claude-md since the bundled CLAUDE.md imports @AGENTS.md)\n  --no-claude-md         Skip writing CLAUDE.md at the workspace root\n                         (useful if the workspace already has its own CLAUDE.md)\n  --no-templates         Skip writing templates/default.md and templates/digest.md\n                         (research engine SKILL falls back to its built-in structure)\n  --no-feedradar-md      Skip writing FEEDRADAR.md at the workspace root\n                         (useful if the workspace already has its own user-facing docs)";
+    readonly "cli.workflow.unknownSubcommand": ({ sub }: {
+        sub: string;
+    }) => string;
+    readonly "cli.workflow.unknownType": ({ type }: {
+        type: string;
+    }) => string;
+    readonly "cli.routine.unknownSubcommand": ({ sub }: {
+        sub: string;
+    }) => string;
+    readonly "cli.routine.unknownType": ({ type }: {
+        type: string;
+    }) => string;
+    readonly "cli.workflow.generateWatchWrote": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.workflow.generateWatchSummary": ({ cron, agent }: {
+        cron: string;
+        agent: string;
+    }) => string;
+    readonly "cli.workflow.generateWatchOverwriting": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.workflow.requiredSecretsHeading": "Required GitHub Actions secrets (Settings → Secrets and variables → Actions):";
+    readonly "cli.workflow.secretCopilotToken": "  GITHUB_TOKEN — auto-provisioned by GitHub Actions (no manual setup needed)";
+    readonly "cli.workflow.secretAgentKey": ({ envKey, agent }: {
+        envKey: string;
+        agent: string;
+    }) => string;
+    readonly "cli.workflow.secretGithubTokenAuto": "  GITHUB_TOKEN — auto-provisioned by GitHub Actions (no manual setup needed)";
+    readonly "cli.workflow.generateCombinedWrote": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.workflow.generateCombinedOverwriting": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.workflow.detailAgent": ({ agent }: {
+        agent: string;
+    }) => string;
+    readonly "cli.workflow.detailCron": ({ cron }: {
+        cron: string;
+    }) => string;
+    readonly "cli.workflow.detailMaxItems": ({ maxItems }: {
+        maxItems: number;
+    }) => string;
+    readonly "cli.workflow.detailFilterTags": ({ tags }: {
+        tags: string;
+    }) => string;
+    readonly "cli.workflow.filterTagsNone": "(none)";
+    readonly "cli.workflow.maxItemsCapWarning": ({ cmd }: {
+        cmd: string;
+    }) => string;
+    readonly "cli.workflow.generateCombinedWithTriageWrote": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.workflow.generateCombinedWithTriageOverwriting": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.workflow.detailWatchCron": ({ cron }: {
+        cron: string;
+    }) => string;
+    readonly "cli.workflow.detailTriageAgent": ({ agent }: {
+        agent: string;
+    }) => string;
+    readonly "cli.workflow.detailResearchAgent": ({ agent }: {
+        agent: string;
+    }) => string;
+    readonly "cli.workflow.detailReviewAgent": ({ agent }: {
+        agent: string;
+    }) => string;
+    readonly "cli.workflow.detailMaxItemsWide": ({ maxItems }: {
+        maxItems: number;
+    }) => string;
+    readonly "cli.workflow.detailOutputMode": ({ mode }: {
+        mode: string;
+    }) => string;
+    readonly "cli.workflow.detailSlackWebhook": ({ webhook }: {
+        webhook: string;
+    }) => string;
+    readonly "cli.workflow.slackWebhookNone": "(none — notify step no-ops)";
+    readonly "cli.workflow.secretsNoneAutoToken": "  (none — every selected agent rides the auto-provisioned GITHUB_TOKEN)";
+    readonly "cli.workflow.secretGithubTokenAutoNoSetup": "  GITHUB_TOKEN (auto-provisioned, no setup needed)";
+    readonly "cli.routine.generateWatchWrote": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.routine.generateWatchSummary": ({ name, repo, cron, model, }: {
+        name: string;
+        repo: string;
+        cron: string;
+        model: string;
+    }) => string;
+    readonly "cli.routine.generateWatchOverwriting": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.routine.generatePipelineWrote": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.routine.generatePipelineSummary": ({ name, repo, cron, model, maxItems, outputMode, }: {
+        name: string;
+        repo: string;
+        cron: string;
+        model: string;
+        maxItems: number;
+        outputMode: string;
+    }) => string;
+    readonly "cli.routine.generatePipelineOverwriting": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.routine.autoMergeWarning": ({ cmd }: {
+        cmd: string;
+    }) => string;
+    readonly "cli.routine.pasteNoApi": "Routines has no declarative apply API — paste this routine into the Web UI by hand:";
+    readonly "cli.routine.pasteStep1": "  1. Open https://claude.ai/code/routines and click New routine.";
+    readonly "cli.routine.pasteStep2": "  2. Fill the form fields from the YAML (Name / Model / Repositories / Trigger / Permissions).";
+    readonly "cli.routine.pasteStep3": "  3. For the multi-line Instructions and Setup script fields, extract them with yq:";
+    readonly "cli.routine.pasteYqInstructions": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.routine.pasteYqSetupScript": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.routine.pasteStep3Bootstrap": "  3. For the Instructions field, paste this SHORT bootstrap prompt (prompt-mode bootstrap):";
+    readonly "cli.routine.bootstrapPromptLine1": ({ name }: {
+        name: string;
+    }) => string;
+    readonly "cli.routine.bootstrapPromptLine2": ({ path }: {
+        path: string;
+    }) => string;
+    readonly "cli.routine.bootstrapPromptLine3": "       `instructions:` block. Run autonomously: AskUserQuestion is NOT available,";
+    readonly "cli.routine.bootstrapPromptLine4": "       and local MCP servers are NOT available in this environment.";
+    readonly "cli.routine.pasteStep3BootstrapSetup": "     For the multi-line Setup script field, extract it with yq:";
+    readonly "cli.routine.bootstrapReuseNote": "     (bootstrap prompt: future instructions edits land via repo commits — no Web UI re-paste needed.)";
+    readonly "cli.routine.pasteStep4": "  4. After registering, copy the issued routine_id (trig_xxxx) back into the YAML and set status: active.";
+    readonly "cli.routine.scheduleNote1": "Note on /schedule (Claude Code): it is conversational — `/schedule <description>`";
+    readonly "cli.routine.scheduleNote2": "to create one, plus `list` / `update` / `run` subcommands. There is no flag-based";
+    readonly "cli.routine.scheduleNote3": "form (no `--name` / `--cron` / `--repo` arguments). It also cannot ingest this YAML";
+    readonly "cli.routine.scheduleNote4": "verbatim, so for the long Instructions field the Web UI paste flow above (yq";
+    readonly "cli.routine.scheduleNote5": "extraction) is the practical path. Finally, the unrestricted-git-push permission an";
+    readonly "cli.routine.scheduleNote6": "auto-merge routine needs is set only via the Web UI 'Allow unrestricted branch";
+    readonly "cli.routine.scheduleNote7": "pushes' toggle — /schedule cannot configure it.";
+    readonly "cli.routine.outputGateBranchPr": "Output gate: this routine writes to a claude/* branch / PR only — never main directly.";
+    readonly "cli.routine.outputGateAutoMerge": "Output gate: this routine opens a claude/* PR then squash-merges it to main (review-complete via step 6).";
+    readonly "cli.routine.pipelineNoSpawn1": "Single Claude session, no spawn: unlike the GHA combined-with-triage";
+    readonly "cli.routine.pipelineNoSpawn2": "workflow, there is NO cross-agent review here — one Claude does every step.";
+    readonly "cli.routine.pipelineItemCaps": ({ maxItems }: {
+        maxItems: number;
+    }) => string;
+    readonly "cli.routine.fireTriggered": ({ routineId, status, }: {
+        routineId: string;
+        status: number;
+    }) => string;
+    readonly "cli.routine.fireSessionCreated": "The session was created — this call does not wait for it to finish.";
+    readonly "cli.init.bundledSkillNotFound": ({ src }: {
+        src: string;
+    }) => string;
+    readonly "cli.init.bundledClaudeSkillNotFound": ({ src }: {
+        src: string;
+    }) => string;
+    readonly "cli.init.bundledGeminiCommandNotFound": ({ src }: {
+        src: string;
+    }) => string;
+    readonly "cli.init.bundledTemplateNotFound": ({ src }: {
+        src: string;
+    }) => string;
+    readonly "cli.init.skippedExisting": ({ file }: {
+        file: string;
+    }) => string;
+    readonly "cli.init.skippedClaudeMdNoAgentsMd": "init: skipped CLAUDE.md because --no-agents-md was passed (the bundled CLAUDE.md imports @AGENTS.md and would dangle)";
+    readonly "cli.init.configLocaleNotYaml": ({ file, reason }: {
+        file: string;
+        reason: string;
+    }) => string;
+    readonly "cli.init.configLocaleNotMapping": ({ file }: {
+        file: string;
+    }) => string;
+    readonly "cli.init.configLocaleSkippedUpdate": ({ file, current, locale, }: {
+        file: string;
+        current: string;
+        locale: string;
+    }) => string;
+    readonly "cli.source.fieldKind": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.fieldUrl": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.fieldName": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.fieldTags": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.fieldKeywords": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.fieldExcludeKeywords": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.fieldTrustLevel": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.fieldLastFetchedAt": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.keywordsEmpty": "(none — items will be filtered out)";
+    readonly "cli.source.valueNone": "-";
+    readonly "cli.source.listHeaderId": "ID";
+    readonly "cli.source.listHeaderKind": "KIND";
+    readonly "cli.source.listHeaderUrl": "URL";
+    readonly "cli.source.listHeaderTags": "TAGS";
+    readonly "cli.source.testHeading": ({ id }: {
+        id: string;
+    }) => string;
+    readonly "cli.source.testCounts": ({ fetched, filtered, matched, }: {
+        fetched: number;
+        filtered: number;
+        matched: number;
+    }) => string;
+    readonly "cli.source.facetSweepNotice": ({ facet, testedValue, totalValues, }: {
+        facet: string;
+        testedValue: string | number;
+        totalValues: number;
+    }) => string;
+    readonly "cli.source.selectorAdoptionHeading": "  selector adoption:";
+    readonly "cli.source.selectorNoCandidate": ({ field }: {
+        field: string;
+    }) => string;
+    readonly "cli.source.selectorAdopted": ({ field, path }: {
+        field: string;
+        path: string;
+    }) => string;
+    readonly "cli.source.paginationPreviewHeading": "  pagination preview (page 0 only — state not mutated):";
+    readonly "cli.source.paginationStrategy": ({ strategy }: {
+        strategy: string;
+    }) => string;
+    readonly "cli.source.paginationNextUrl": ({ nextUrl }: {
+        nextUrl: string;
+    }) => string;
+    readonly "cli.source.paginationEndOfPagination": "(end of pagination)";
+    readonly "cli.source.paginationLinkNext": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.paginationNextCursor": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.paginationAbsent": "(absent)";
+    readonly "cli.source.testNoMatched": "  (no matched items)";
+    readonly "cli.source.testShowing": ({ shown, total }: {
+        shown: number;
+        total: number;
+    }) => string;
+    readonly "cli.source.testItemTitle": ({ index, title }: {
+        index: number;
+        title: string;
+    }) => string;
+    readonly "cli.source.testItemUrl": ({ url }: {
+        url: string;
+    }) => string;
+    readonly "cli.source.testItemMatchedKeywords": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.testItemMatchedFields": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.testItemContent": ({ value }: {
+        value: string;
+    }) => string;
+    readonly "cli.source.testMoreItems": ({ count }: {
+        count: number;
+    }) => string;
+    readonly "cli.source.recipesNoValid": "source recipes: no valid recipes found (all bundled entries failed to load)";
+    readonly "cli.source.recipesHeaderName": "NAME";
+    readonly "cli.source.recipesHeaderKind": "KIND";
+    readonly "cli.source.recipesHeaderDescription": "DESCRIPTION";
+    readonly "cli.source.recipesErrorsHeading": "Recipes with errors:";
+    readonly "cli.source.recipesErrorRow": ({ name, error }: {
+        name: string;
+        error: string;
+    }) => string;
+    readonly "cli.source.recipesErrorUnknown": "(unknown error)";
+    readonly "cli.source.recipesApplyHeading": "Apply a recipe with:";
+    readonly "cli.source.recipesApplyExample": "  radar source add <id> --recipe <name> [--keywords <kw>] [--tags <t>] [--name <display>]";
+    readonly "cli.triage.progressTriaging": ({ count, sourceId, agent, }: {
+        count: number;
+        sourceId: string;
+        agent: string;
+    }) => string;
+    readonly "cli.triage.confirmApply": "Apply these decisions? [y/N]";
+    /** `radar state` / `radar state prune` help text. */
+    readonly "cli.state.help": "Usage: radar state prune <source> --keep <N>\n\nTrim state/<source>.yaml lastSeenIds to its newest N ids (FIFO; oldest dropped first).\nUse it to shrink a state file that has already grown large from facet sweeps.\n\nOptions:\n  --keep <N>          Keep the newest N ids; drop the rest (required)\n  --older-than <dur>  Not supported (lastSeenIds carries no per-id timestamps)\n  -h, --help          Show this help";
+    /** stderr line when arg parsing fails (unknown flag / missing value). */
+    readonly "cli.state.parseError": ({ reason }: {
+        reason: string;
+    }) => string;
+    /** stderr line for an unrecognized `state` subcommand. */
+    readonly "cli.state.unknownSubcommand": ({ sub }: {
+        sub: string;
+    }) => string;
+    /** stderr line when `<source>` positional is missing. */
+    readonly "cli.state.missingSource": "state prune: missing <source>";
+    /** stderr line when neither `--keep` nor a supported mode is given. */
+    readonly "cli.state.keepRequired": "state prune: --keep <N> is required";
+    /** stderr line when `--older-than` is used (deliberately unimplemented). */
+    readonly "cli.state.olderThanUnsupported": "state prune: --older-than is not supported (lastSeenIds carries no per-id timestamps); use --keep <N>";
+    /** stderr line when `--keep` is not an integer. */
+    readonly "cli.state.invalidKeepInteger": ({ raw }: {
+        raw: string;
+    }) => string;
+    /** stderr line when `--keep` is not a positive integer. */
+    readonly "cli.state.invalidKeepPositive": ({ raw }: {
+        raw: string;
+    }) => string;
+    /** stderr line when state/<source>.yaml does not exist. */
+    readonly "cli.state.sourceNotFound": ({ sourceId }: {
+        sourceId: string;
+    }) => string;
+    /** Summary line when the list is already within the keep window (no write). */
+    readonly "cli.state.pruneNoop": ({ sourceId, count, keep, }: {
+        sourceId: string;
+        count: number;
+        keep: number;
+    }) => string;
+    /** Summary line after a successful trim + write. */
+    readonly "cli.state.pruneDone": ({ sourceId, before, after, dropped, }: {
+        sourceId: string;
+        before: number;
+        after: number;
+        dropped: number;
+    }) => string;
+};
+/** Union of all valid message keys. */
+export type MessageKey = keyof typeof en;
+/**
+ * Widen a single English catalog entry into the shape every locale must
+ * satisfy for that key. The `as const` on {@link en} narrows string entries to
+ * *literal* types ("Show this help"), which would force `ja` to repeat the
+ * English text verbatim — so we widen string entries back to `string` while
+ * preserving function entries' precise param/return signature (that is the
+ * part that must stay identical across locales, since `t`'s param type is
+ * derived from it).
+ */
+type LocaleEntry<T> = T extends (...args: infer A) => infer R ? (...args: A) => R : string;
+/**
+ * The catalog shape every locale must satisfy. Derived from the English
+ * catalog so that `ja` (and any future locale) is required — at compile time —
+ * to provide the exact same key set, with string entries free to differ in
+ * wording but function entries pinned to the same param/return shape.
+ */
+export type Messages = {
+    [K in MessageKey]: LocaleEntry<(typeof en)[K]>;
+};
+export {};
+//# sourceMappingURL=en.d.ts.map