report-bug

Report Bug

Reply in Russian. This channel reports defects of the tool, never problems of the user's

project. The server triages, anonymizes, assembles the issue and publishes it; the skill only

carries the conversation and the approval.

The plugin runs on commercial codebases. Never pre-redact by hand and never paste source

code, paths, repo/branch/file names, task keys, board URLs, hosts or tokens into the arguments

in the hope of "cleaning them up" — pass what you observed and let the server anonymize it. The

sanitizer is deterministic Python; a model rewriting the text first only hides what it should

have removed.

1. Decide whether it is ours. Pick kind from the tool contract, and pass it as observed —

the server, not you, decides whether the channel speaks:

• ours: tool_exception, contract_violation, skill_impossible, skill_contradiction,

invariant_violation, deterministic_repro;

• not ours: environment, external_service, user_code, permission, llm_behaviour.

The one exception: the model misbehaved because a skill instruction was contradictory →

still llm_behaviour, but set caused_by_skill_instruction=True (a prompt bug is our bug).

A not_reported status is a normal outcome — report nothing to the user beyond a brief note.

1. Pick severity. blocker (no workaround), degraded (workaround or manual fallback

exists), contract (documentation and behaviour disagree, work continues). Offer blocker

and degraded immediately; the server marks contract with defer=true — collect those and

offer them as one batch at the end of the session.

1. Preview (never skip). Call

   report_bug(kind=<kind>, summary=…, expected=…, actual=…, steps=[…], severity=<level>,
              tool=<mcp tool name>, skill_step=<skill and step>, error_class=<exception class>,
              details=…, repo=<owner/name>, branch=<branch>,
              client_environment={"orchestrator_model": …, "subagent_models": …,
                                  "mode": "subagent|inline", "cli": …, "cli_version": …},
              scale={"clusters": N, "files": N, "findings": N, "tasks": N},
              index_drift=<int or null>)

without confirmed. Nothing is published. Handle the status: disabled — the channel is off

for this repo or deploy, say so and stop; not_reported / suppressed — stop quietly.

1. Show and ask. Show the returned issue_text in full, verbatim — no summary, no

abridgement — plus the target repository, the environment_keys list, and the

identity_notice: the issue is published from the user's GitHub account and their username

will be visible in a public repository; the alternative is to decline and open the issue by

hand from the prepared markdown. Offer to trim the Environment block: any lines, or the whole

block. Then ask for an explicit yes.

1. Publish only on an explicit yes. Repeat the same call with confirmed=True and, if the

user trimmed anything, environment_exclude=[…] (or environment_include=[…]). In a

headless, cron or background run there is no human to approve: pass non_interactive=True,

which makes the server return a fallback markdown instead of publishing. Never publish

autonomously in any mode.

• published — report the issue URL.
• commented — a matching open issue existed; report that a comment was added and give both

URLs.

• fallback — publication was not possible (no token, no rights, no network, headless):

relay the reason, show the markdown and the fallback_url so the user can post it by hand.

This is not a session failure — continue the work that was interrupted.

1. On a refusal call report_bug(kind=…, summary=…, decline=True) with the same arguments,

so the same symptom is not offered again in this session.

Every read is fail-open, and the confirmed=True call is the only write. If the channel itself

fails, say so in one line and carry on with the original task.