@miroshnik/elves 0.0.0 → 2026.1018.0

package/skills/github/locales/en.json

@@ -0,0 +1,449 @@
+{
+  "issueTypes": {
+    "task": "Task",
+    "bug": "Bug",
+    "epic": "Epic"
+  },
+  "sections": {
+    "questions": "## Questions",
+    "scenarios": "## Scenarios"
+  },
+  "labels": {
+    "questions": "questions",
+    "questionsDescription": "Open questions in the «## Questions» section",
+    "epicDescription": "Epic: a large task with subtasks",
+    "externalBlocker": "external blocker"
+  },
+  "status": {
+    "backlog": "Backlog",
+    "inProgress": "In progress",
+    "done": "Done"
+  },
+  "fields": {
+    "estimate": "Estimate, h",
+    "actual": "Actual, h",
+    "tokens": "Tokens, M",
+    "cost": "Cost, $"
+  },
+  "views": {
+    "board": "Board",
+    "table": "Table",
+    "roadmap": "Roadmap"
+  },
+  "labelMarkers": {
+    "decision": "Decision:",
+    "slice": "Slice:",
+    "architecturePath": "tests/architecture — rule or module {name}"
+  },
+  "comments": {
+    "state": "State",
+    "actual": "Actual:",
+    "closedByPr": "Closed by PR {prs}: GitHub didn't link the PR to the task",
+    "externalBlocker": "External blocker:"
+  },
+  "subagentPrompt": {
+    "task": "Task",
+    "epic": "epic"
+  },
+  "mainRed": {
+    "title": "{base} is red",
+    "check": "check {names}",
+    "checks": "checks {names}"
+  },
+  "actualize": {
+    "lead": "{task} #{number} ({epicWord} #{epic}): epic refresh after the merge — bring the epic's open tasks in line with what shipped.",
+    "fetch": "The whole assignment — the texts of the epic's open tasks, the PR files, what the script named, the checks by meaning — is printed by `{command}`: run it first, outside the sandbox (gh doesn't work in it); don't collect the tasks and the PR yourself.",
+    "shipped": "Repository {repo}. Shipped: #{number} «{title}», {shipped}.",
+    "prs": "PR {list}",
+    "noPr": "no PR found — commits {command}",
+    "files": "PR #{pr} files:",
+    "epic": "## Epic #{epic} «{title}»",
+    "openTasks": "## The epic's open tasks — its sub-issues, not a list in the epic's description",
+    "openTask": "### #{number} «{title}»",
+    "noBody": "(no description)",
+    "copies": "## Copies of links in text — remove them: GitHub keeps the links (sub-issue, blocked by)",
+    "copy": "- #{number}: «{line}»",
+    "answers": "## Answers to open questions in comments — check that it answers that question and move it into «{questions}» (✅ and the answer at the question, same numbering); if not — leave it",
+    "commentAnswer": "- #{number}, question {k}: «{text}» — {url}",
+    "checks": "## Checks by meaning — yours (canon — reference.md of the github skill, «Epic refresh on task close»); the mechanics — blocked by on done tasks, the questions label without open questions, milestones without open tasks — the script did",
+    "scope": "You change only GitHub tasks — description, «{questions}», links, status; the github skill script — `{script}`: not done — `task drop <N>`, a new one — `task new … --branch-type <type> --epic {epic}` (it sets the estimate itself); an answer at a question — `task answer <N> <k> \"<answer>\"`. Don't touch code, branches or git; don't close #{number}, epic #{epic} or their milestones — task close does that after you.",
+    "comment": "The result — always, as the last step: a comment on epic #{epic} (`gh issue comment {epic} --repo {repo}`), one line «{report}» — after the colon what you fixed, nothing to fix — «the block is current». By it `task close {number}` sees the refresh is over: without it the close refuses.",
+    "answer": "Answer — fixes one per line with task numbers and questions to the owner, if any; otherwise «The block is current».",
+    "linkWords": "blocked by|blocks|after|depends on|waits for",
+    "report": "Refresh after #{number}, result: {text}",
+    "mechanics": "Refresh after #{number}, script: {fixes}.",
+    "unblocked": "#{task}: blocked by done {blockers} removed",
+    "unlabeled": "#{task}: label «{label}» removed — no open questions",
+    "milestone": "milestone «{title}» closed — no open tasks in it"
+  },
+  "queue": {
+    "prompt": "{task} #{number} in {repo}{epic}: you are an executor of the dispatcher session. The whole assignment is printed by `{command}` — call it first, outside the sandbox (gh doesn't work in it).",
+    "epic": " ({epicWord} #{epic})",
+    "lead": "{task} #{number} «{title}» in {repo}{epic}: you are an executor of the dispatcher session — do the task whole by the canon, like a session in auto mode: the task's questions, `{script} task status {number} \"{inProgress}\" --branch <type>/{number}-<slug>`, the branch from a fresh origin/main, code and tests, PR, green CI, `pr premerge`, merge, deploy, the epic refresh, `{script} task close {number}`.",
+    "resume": "The task is already «{inProgress}» and has a branch {branches} — a restart: continue its work. The branch is checked out in another worktree (`git worktree list`) — work in that one, not in your new one: in Claude Code — `EnterWorktree` with its path; uncommitted work — `git status` there. In no worktree — check it out in yours.",
+    "subagent": "You are a subagent, not a session:",
+    "session": "- don't rename or archive the session and don't write the last line («{done}») — the dispatcher does;",
+    "wait": "- wait for CI and the deploy with a regular call, not in the background: a background command doesn't wake a subagent, and a Bash call lives up to 10 minutes — `{waitCi} pr <PR> --timeout 540` (after the merge — `merged <PR>`), on TIMEOUT — the same call again;",
+    "git": "- git — in separate calls, without `cd`, `&&` and `|`: worktree isolation refuses a compound command with git;",
+    "subagents": "- writing subagents — launch as needed, no limit: each gets its own worktree and «{task} #{number}» at the start of its prompt (`est` links its work by it); bring their commits into your branch, remove their worktrees and branches yourself after the merge — what didn't go, name in the answer;",
+    "live": "- while any of your subagents works, don't answer: wait for their answers — a background subagent wakes you with its answer; an answer with live subagents looks like a failure, and the dispatcher would give the task to a second executor next to you. Can't wait — answer `waits for subagents: <which and what they do>`: it isn't `failed`, there will be no second executor;",
+    "found": "- work found outside the task — `{script} task new …` (work of the task's epic — with `--epic`: the dispatcher picks it up) — name it in the answer: whether to queue it is the owner's call;",
+    "question": "- a question without a clear recommendation — into «{questions}» of the task; don't start the code that depends on it and answer the dispatcher: the owner's answer comes back here.",
+    "answer": "The answer to the dispatcher — one line: `merged #<PR>` · `question: <the question, options, recommendation>` · `waits for subagents: <which and what they do>` · `failed: <what stopped and where>`.",
+    "alive": "{task} #{number} in {repo}: the task's previous executor or its subagent is alive — the `!` lines above. Don't take the task and change nothing: answer the dispatcher in one line `waits for the previous executor: <the worktree and why it is alive>` — the dispatcher restarts the task only when no worktree of the previous executor and its subagents is locked by a live process or gets commits.",
+    "cloudEpic": " ({epicWord} {epic})",
+    "cloud": "{task} #{number} «{title}» in {repo}{epic}: you are a cloud executor of the dispatcher session — do the task whole by the canon, like a session in auto mode: the task's questions, code and tests, PR, green CI, merge, deploy.",
+    "cloudDoc": "- the cloud — by `docs/cloud-sessions.md` of the canon, read it first: of the github skill's scripts `task show`, `task answer` and `task new` work there (over REST), the rest refuse, the scenarios section — by editing the description over REST, project fields aren't set from the cloud; the branch is the one the cloud assigned, don't rename it;",
+    "cloudClose": "- after the merge — its section «Closing a task from the cloud»: the «{actual}» comment of `est fact {number}` and a «{state}» comment with what the cloud can't do — both into the task;",
+    "cloudDispatcher": "- the dispatcher waits for the task to close and closes it locally — the actual, the status, the merged branch, archiving this session: don't message it, don't archive the session;",
+    "cloudQuestion": "- a question without a clear recommendation — into «{questions}» of the task and to the owner in this session, don't start the code that depends on it; stopped (a question, a failure, a limit) — a «{state}» comment into the task."
+  },
+  "est": {
+    "answer": "Answer",
+    "manual": "+ manually:",
+    "reason": "Reason:",
+    "hours": "h",
+    "closingWords": "close closes closed fix fixes fixed resolve resolves resolved",
+    "stopWords": "the and for with from into",
+    "fact": {
+      "unavailable": "Actual unavailable: no sessions found (coverage none).",
+      "body": "{h} h active in {agents} ({estimate}). {sessions}, {prompts},{subagents} wall {wall} h, coverage {cov}.",
+      "estimate": "estimate {h} h{ratio}",
+      "noEstimate": "no estimate",
+      "sessions": {
+        "one": "session",
+        "few": "sessions",
+        "many": "sessions",
+        "other": "sessions"
+      },
+      "prompts": {
+        "one": "prompt",
+        "few": "prompts",
+        "many": "prompts",
+        "other": "prompts"
+      },
+      "subagents": {
+        "one": "subagent",
+        "few": "subagents",
+        "many": "subagents",
+        "other": "subagents"
+      },
+      "commits": {
+        "one": "commit",
+        "few": "commits",
+        "many": "commits",
+        "other": "commits"
+      },
+      "prs": " PR {list};",
+      "noPr": " no PR;",
+      "diff": " {commits}, diff {diff}.",
+      "diffLines": "{n} lines",
+      "diffNa": "n/a (no PR)",
+      "shared": "shared {unit} with {list} (share 1/{k})",
+      "commitUnit": "commit {oid}",
+      "taken": " Not counted again: {h} h already in the actual of #{issue}.",
+      "overlap": " Overlap with the actual of #{issue}: {h} h — recompute #{issue}.",
+      "cloudMissing": " Cloud session https://claude.ai/code/{sid} not imported — est cloud-import.",
+      "tokens": "Tokens: {total} M",
+      "tokensSplit": " (input {in} · output {out} · cache write {cw} · cache read {cr})",
+      "cost": "; cost at API rates ≈ ${usd}",
+      "unpriced": "; no price (not in the price list): {models}",
+      "steps": "Turns: {n} (subagents {agents}, their turns {agentSteps}), preamble {preamble}K, context at the end {end}K, turns with context > {tail}K — {share} %.",
+      "waits": "Waits: CI {ci} min · after the merge {merged} · checks {checks}{slot} · rest {rest}.",
+      "waitsSlot": " (slot queue {slot})",
+      "and": " and ",
+      "cloudAgent": "a Claude Code cloud session"
+    },
+    "cloud": {
+      "actual": "Actual (cloud):",
+      "body": "{h} h active in a Claude Code cloud session, {prompts}.",
+      "tokens": " Tokens: {total} M{cost}.",
+      "cost": ", at API rates ≈ ${usd}",
+      "fields": " Session: https://claude.ai/code/{sid}. The local session sets the project fields: est fact {number} --write.",
+      "unavailable": "Actual unavailable (cloud): the task was done in a Claude Code cloud session — est can't see the GitHub project there; a local session gives the number by importing this session's events (est cloud-import) (coverage none).",
+      "session": " Session: https://claude.ai/code/{sid}."
+    },
+    "estimate": {
+      "headline": "Estimate: {h} h",
+      "tokens": ", ≈ {tok}M tokens",
+      "partial": " (tokens and cost from {k} of {n} analogs)",
+      "body": "{headline} (type {type}, confidence {conf}; {basis}). Analogs{auto}: {analogs}.{correction}{spread} {k}.",
+      "auto": " (picked by the script)",
+      "forecast": "forecast from the analogs' actuals",
+      "expertOver": "expert estimate; the analogs would give {h} h, tokens and cost rescaled ×{ratio}",
+      "expert": "expert estimate, no analogs with an actual",
+      "spread": " The analogs' actuals spread {min}…{max} h — the median is taken.",
+      "correction": " Correction: ×{mult}{note}.",
+      "tokCorrection": " Token and cost correction: ×{mult}{note}.",
+      "k": "k={k} (n={n}, level «{level}»; for reference, not applied to the forecast)",
+      "noK": "k: no history",
+      "levelRepo": "repo",
+      "levelAll": "all repos",
+      "none": "none",
+      "otherProject": "from project {repo}: {list}",
+      "analog": "{label} (actual {h} h{why})",
+      "unknown": "{label} (actual unknown)",
+      "partialCoverage": "{label} (actual {h} h, coverage {cov} — not counted)",
+      "notInProject": "{label} (not in the project)",
+      "labels": {
+        "one": "label",
+        "few": "labels",
+        "many": "labels",
+        "other": "labels"
+      },
+      "type": "type {type}",
+      "words": {
+        "one": "word",
+        "few": "words",
+        "many": "words",
+        "other": "words"
+      },
+      "size": "description ×{ratio}"
+    }
+  },
+  "updateCommit": "Elves flow {version}",
+  "updateTask": "Update the Elves flow",
+  "formerly": {
+    "updateTask": "Update the ai-dev flow"
+  },
+  "standardIssue": "Standard ·",
+  "autoAnswer": "✅ auto",
+  "lastLine": {
+    "done": "All done. The session can be closed.",
+    "questions": "All done, but there are questions:",
+    "remaining": "Remaining:"
+  },
+  "prSpecSection": "## Spec (tests)",
+  "spec": {
+    "tests": {
+      "one": "test",
+      "few": "tests",
+      "many": "tests",
+      "other": "tests"
+    },
+    "lint": {
+      "allRules": "all rules",
+      "noReason": "no reason"
+    },
+    "doc": {
+      "mark": "<!-- spec-doc: generated from test names, don't edit by hand -->",
+      "title": "Specification",
+      "intro": "Generated from the `tests/` tree, test names and their JSDoc (the `spec` skill, `spec-doc`). Don't edit by hand: edit the tests.",
+      "capabilities": "What the system does",
+      "architecture": "What it's made of",
+      "standards": "Which rules the code obeys",
+      "skippedCount": {
+        "one": "skipped",
+        "few": "skipped",
+        "many": "skipped",
+        "other": "skipped"
+      },
+      "failingCount": {
+        "one": "failing",
+        "few": "failing",
+        "many": "failing",
+        "other": "failing"
+      },
+      "variants": {
+        "one": "variant",
+        "few": "variants",
+        "many": "variants",
+        "other": "variants"
+      },
+      "skipped": "skipped",
+      "failing": "failing",
+      "todo": "todo",
+      "outside": "Outside the tree",
+      "outsideIntro": "Tests without a home in {homes} and {last} — move them:",
+      "none": "— none.",
+      "rules": "Rules"
+    },
+    "c4": {
+      "title": "Architecture",
+      "intro": "Generated from the model `tests/architecture/model.ts` (the `spec` skill, `spec-doc`): C4 diagrams and a table of modules. Edit the model; the architecture rules check it against the code.",
+      "system": "System",
+      "context": "System and external systems",
+      "containers": "Containers",
+      "components": "Modules",
+      "perimeter": "perimeter",
+      "viaModule": "via module {modules}",
+      "viaModules": "via modules {modules}",
+      "uses": "uses",
+      "dependsOn": "depends on",
+      "calls": "calls",
+      "library": "library",
+      "table": "| Module | Purpose | Directory | API | Depends on | Packages |",
+      "summary": "model: {parts}",
+      "moduleCount": {
+        "one": "module",
+        "few": "modules",
+        "many": "modules",
+        "other": "modules"
+      },
+      "containerCount": {
+        "one": "container",
+        "few": "containers",
+        "many": "containers",
+        "other": "containers"
+      },
+      "externalCount": {
+        "one": "external system",
+        "few": "external systems",
+        "many": "external systems",
+        "other": "external systems"
+      }
+    },
+    "diff": {
+      "base": "_Base: `{base}`._",
+      "unchanged": "Tests didn't change.",
+      "removed": "Removed",
+      "changed": "Changed",
+      "added": "Added",
+      "empty": "**{title}:** none.",
+      "outsideMark": "outside the tree",
+      "moved": "**Moved into the tree ({n}):** the same names as outside `{tests}/` on the base; from {files}.",
+      "movedFolder": "{tests} from {files}",
+      "files": {
+        "one": "file",
+        "few": "files",
+        "many": "files",
+        "other": "files"
+      },
+      "summary": "**Summary by folder** — {tests}, over the threshold of {limit}: the full list — `spec-diff --full` (in CI — the job summary).",
+      "folder": "Folder",
+      "harnessColumn": "Of them, from the harness",
+      "total": "Total",
+      "outsideFiles": "**Outside the `{tests}/` tree** changed test files: {files}.",
+      "notStatements": "⚠️ **Names that aren't statements: {n}** — new in this PR; `spec-doc` names them in warnings.",
+      "scenarios": "Task scenarios",
+      "noScenarios": "The issue has no `{section}` section — nothing to check against.",
+      "becameTests": "**Became tests ({n}):** in the lists above.",
+      "noTest": "no test",
+      "extraMark": "beyond scenarios",
+      "extraTitle": "Tests beyond scenarios",
+      "extraListed": "in the lists above, with the «{mark}» mark.",
+      "extraFull": "as a list — `spec-diff --full`.",
+      "harnessCheck": "harness check",
+      "fromReport": "from the report",
+      "harnessNote": "_Harness tests — from the report; base — branch {branch} (source {source}{gap})._",
+      "harnessGap": " older than the diff base {sha}: the lists may contain tests of PRs merged between them",
+      "noSpecBase": "_Harness tests: branch {branch} has no tests.json for the base — a diff by sources, harness tests aren't visible in it._",
+      "partialReport": "⚠️ **Incomplete report:** it has no tests from {folders} whose names only a run knows — their tests weren't compared ({n} in branch {branch}) and aren't in «{removed}»; the full diff — with the report of a run of all tests.",
+      "modelModule": "module {module}",
+      "modelDependency": "dependency {from} → {to}",
+      "modelPackage": "package {package} of module {module}",
+      "registry": "registry",
+      "registryNamed": "registry «{value}»",
+      "rule": "rule",
+      "ruleNamed": "rule {value}",
+      "deadCode": "code without a consumer",
+      "deadCodeNamed": "code without a consumer ({value})",
+      "architecture": "architecture model",
+      "modelTitle": "Architecture model",
+      "exceptionsTitle": "Exceptions",
+      "checksTitle": "Harness checks",
+      "removedKind": "{title} — removed",
+      "addedKind": "{title} — added",
+      "summarized": "**{title} ({n}), as a summary:**"
+    },
+    "claims": {
+      "describe": "Every entry point is called by at least one capability test",
+      "registry": "entry points",
+      "unique": "entry-point ids do not repeat in the registry",
+      "called": "{entry} is called by a capability test",
+      "known": "ids from the log are in the registry"
+    },
+    "harness": {
+      "registryNotEmpty": "registry «{registry}» is not empty{tag}",
+      "registryFinds": "registry «{registry}» finds {items}{tag}",
+      "violator": "violator does not pass{tag}: {name}",
+      "oneRecord": "one record per element{tag}",
+      "markOneElement": "a mark belongs in one element's file{tag}",
+      "elementFiles": "element files from fileOf exist{tag}",
+      "outside": "outside scope{tag}: {item}",
+      "exception": "exception{tag}: {item} (#{issue})",
+      "exceptionFiles": "exceptions are one file per element in exceptions/, not exceptions.ts",
+      "exceptionJson": "exceptions are <element>.json files in the decision folder's exceptions/",
+      "exceptionRules": "exceptions with a rule belong to the folder's invariant rules",
+      "markRules": "marks with a rule belong to the folder's invariant rules",
+      "badExample": "rule {rule} has a «not allowed» example",
+      "bad": "not allowed",
+      "good": "allowed",
+      "outsideExample": "outside scope",
+      "codeFiles": "there are code files in {dirs}",
+      "lintExceptions": "exceptions in {file}: {rules}{issues}",
+      "knip": {
+        "files": "no files without a consumer",
+        "exports": "no exports without a consumer",
+        "types": "no types without a consumer",
+        "dependencies": "no dependencies without an import",
+        "unlisted": "no imports of unlisted packages",
+        "unresolved": "no unresolved imports",
+        "enumMembers": "no enum members without a consumer",
+        "nsMembers": "no namespace members without a consumer",
+        "duplicates": "no duplicate exports",
+        "binaries": "no calls to unlisted binaries",
+        "catalog": "no unused catalog entries",
+        "catalogReferences": "no references to missing catalog entries",
+        "known": "all knip findings are of known kinds{tag}",
+        "hints": "no knip configuration hints{tag}"
+      },
+      "ignoreNoReason": "outside scope without a reason: {items}",
+      "env": {
+        "inCode": "environment variables in the code",
+        "declaredName": "{name} is declared",
+        "undeclared": "a variable without a declaration",
+        "declared": "declared environment variables",
+        "readName": "{name} is read in the code",
+        "unread": "declared and not read"
+      }
+    },
+    "architecture": {
+      "dirsRegistry": "code directories",
+      "dirName": "directory {dir} is in module {module}",
+      "dirViolator": "a directory outside the modules",
+      "workspaceRegistry": "workspace packages",
+      "workspaceName": "workspace package {path} is in the code roots",
+      "workspaceViolator": "a workspace package outside the roots",
+      "importsRegistry": "external packages of modules",
+      "importsName": "{module} imports {package}",
+      "importsViolator": "a package not allowed for the module",
+      "allowedRegistry": "allowed packages of the model",
+      "allowedName": "{module} uses allowed package {package}",
+      "allowedViolator": "an allowed package without an import",
+      "containersRegistry": "modules in containers",
+      "libraryName": "library {module} is in containers {containers}",
+      "moduleName": "module {module} is in container {container}",
+      "containersViolator": "a module outside the containers",
+      "edgesRegistry": "module dependencies",
+      "edgeName": "dependency {from} → {to} is within a container",
+      "edgeViolator": "a dependency across containers",
+      "unitsRegistry": "deployable units",
+      "unitName": "deployable unit {unit} is container {container}",
+      "unitViolator": "a unit outside the model",
+      "clientsRegistry": "storage clients in containers",
+      "clientName": "client {package} of storage {storage} is in container {container}",
+      "clientViolator": "a client without a link",
+      "hostsRegistry": "hosts of external systems",
+      "hostName": "host {host} is only in {adapters}",
+      "hostPerimeter": "host {host} of external system {system} isn't in the code: no adapter",
+      "hostViolator": "a host outside the model",
+      "inAdapter": "adapter {list}",
+      "inAdapters": "adapters {list}",
+      "packagesRegistry": "packages of external systems",
+      "packageName": "package {package} of external system {system} is only with {adapters}",
+      "packagePerimeter": "package {package} of external system {system} is with no module: no adapter",
+      "packageViolator": "a package without an adapter",
+      "withAdapter": "adapter {list}",
+      "withAdapters": "adapters {list}",
+      "envRegistry": "environment keys of external systems",
+      "envNoun": "key",
+      "headersRegistry": "headers of external systems",
+      "headerNoun": "header",
+      "readName": "{noun} {key} of external system {system} is read only by adapter {list}",
+      "readNameMany": "{noun} {key} of external system {system} is read only by adapters {list}",
+      "readPerimeter": "{noun} {key} of external system {system} isn't in the code: no adapter",
+      "readViolator": "{noun} outside the adapter"
+    }
+  }
+}