Update to Qodo

{
  "description": "Review local changes with Qodo during substantive coding milestones and before a PR or completed-work handoff. Use light background checkpoints while coding, collect and assess findings with session context, and run a final review before handing off. Also use for \"review my local diff\", \"pre-PR review\", or \"run qodo review\". Use qodo-review-resolver for findings already posted on a PR.",
  "included_files": [
    {
      "relative_path": "agents/openai.yaml",
      "size_in_bytes": 343
    },
    {
      "relative_path": "references/connected-progress.md",
      "size_in_bytes": 2048
    },
    {
      "relative_path": "references/local-triage.md",
      "size_in_bytes": 2725
    },
    {
      "relative_path": "references/skill-updates.md",
      "size_in_bytes": 1685
    }
  ],
  "name": "qodo-review",
  "skill_md_contents": "---\nname: qodo-review\ndescription: Review local changes with Qodo during substantive coding milestones and before a PR or completed-work handoff. Use light background checkpoints while coding, collect and assess findings with session context, and run a final review before handing off. Also use for \"review my local diff\", \"pre-PR review\", or \"run qodo review\". Use qodo-review-resolver for findings already posted on a PR.\nowner: Qodo\nmetadata:\n  vendor: qodo\n  version: \"1.10.5\"\n  recommended: \"true\"\n  package: \"qodo\"\n  distribution: \"marketplace\"\n  instruction_mode: \"embedded\"\n---\n\n# Local Review\n\n## Description\n\nUse the `qodo` CLI to review **local changes during coding and before handing off completed work**. `qodo review` diffs your working tree against a base branch, includes new/untracked files, and sends the diff plus any\n**coding-session context** you supply to Qodo's review engine. It returns structured findings you then evaluate and — with the user's say-so (or `autofix`) — fix in code. Nothing is pushed and no\nPR is created; only the base commit must already be on the remote (the reviewer clones it).\n\nUse this skill for local changes, including unpushed work on an existing PR. Use `qodo-review-resolver`\nto work on findings from the PR's remote review; do not duplicate that review for an unchanged pushed snapshot.\n\n## Prerequisites\n\n- The Qodo CLI is installed and authenticated, and the review capability is enabled.\n- The comparison base exists on the remote; local changes and context need not be pushed.\n- The coding-session context and any ticket or design references are ready to attach.\n\n## Choose when and how deeply to review\n\n| Situation | Selection |\n|---|---|\n| A coherent milestone during substantive coding | `--fast --async`: light checkpoint; continue useful coding and collect the result. |\n| Ordinary final review before opening/updating a PR or handing off completed work | Omit both depth flags: auto. Collect and assess the result before claiming review completion. |\n| User intent calls for unusually thorough scrutiny, or a known high blast radius warrants it | `--deep`, with a brief reason tied to the request or affected behavior. |\n\nAutomatic coding checkpoints always use `--fast`. A deliberate deep review can happen earlier when\none of the exceptions above applies. A request such as \"examine subtle races thoroughly\" can justify\nit without the word \"deep\"; generic \"review\" or \"double-check\" does not. Identify concrete impact,\nsuch as shared authorization, a destructive migration, or a contract used by multiple services.\nDiff size, session length, PR readiness, or a security-related filename alone do not justify deep.\n\nWith **no flag**, the CLI omits depth and the reviewer/deployment selects it. Auto can select deep;\nit is not guaranteed standard and does not impose a spending cap. There is no `--standard` flag.\n`--fast` and `--deep` are mutually exclusive; depth is selected anew for each invocation.\n\n## Checkpoints and final handoff\n\n- Review a completed, testable slice when its feedback can guide the remaining work. Do not review\n  unfinished exploration, every edit, trivial changes automatically, or simply because time passed.\n  Respect the user's review scope and budget. A pause for a question or approval is not a final handoff.\n- Keep at most one automatic checkpoint active per task. Retain its operation ID, submitted scope\n  and snapshot/context association in the task's existing state. Poll status at natural pauses while\n  doing useful work; do not launch another review to check progress or re-review unchanged inputs.\n- Collect every submitted result within its retention window. Recheck findings against current code\n  before acting: the working tree may have changed. A superseded result cannot certify newer work.\n  Use the existing CLI lifecycle; no separate sub-agent or scheduler is required.\n- Before final review, collect the outstanding checkpoint and reconcile its findings. Review the\n  full intended change with auto, or justified deep, rather than handing off on a light checkpoint.\n  Remove temporary path restrictions that would leave part of the intended change unreviewed.\n  If the same snapshot already has completed final coverage with compatible context, use that result.\n- Batch authorized fixes, verify them, then re-review changed work. Keep `--fast` for checkpoint\n  fixes; retain the requested auto or justified deep mode for final-review fixes. Let the engine\n  determine incremental eligibility; auto may route differently on each pass. Do not manually switch\n  final fixes to `--fast` or force `--deep` just to pin auto routing. If work returns to substantial\n  implementation, resume light checkpoints and establish final coverage again before handoff.\n- If another pass repeats the same concern without actionable progress, stop the automatic loop and\n  report the remaining issue and needed decision/check. Do not buy repeated passes to chase zero.\n  Pending, failed, partial or superseded review is not clean; surface remaining findings and coverage.\n\n## Prepare a PR handoff\n\nWhen preparing to open or update a PR, prefer committing the intended changes before your final local review, following the user's commit policy.\nThis gives Git reviews that support local-to-PR handoff a verified commit to continue from, avoiding another review of code already covered locally.\nIf you make further edits afterward, Git review will cover those changes. To include them in the handoff too, commit and review them locally again.\nCommitting is optional. Without a usable reviewed commit, Git review follows its normal review scope.\n\n## Instructions\n\nPreserve notices, attach self-contained context, show progress, use a suitable timeout,\nread the structured result, and act on findings.\n\n## Handle a skill update notice\nTreat `QODO_NOTICE` updates as passive, even if an older CLI requests action. Continue the task\nwithout inventory or update questions; mention each event at most once. Dismissal leaves recorded maintenance\npolicy and opt-outs unchanged. Updated skills load next session; do not interrupt this one.\nFor user-requested updates, follow the [manual-update procedure](references/skill-updates.md).\n\n## Runtime compatibility gate\nResolve the executable using this skill's command-not-found fallback, then run `<qodo> --version`\nwith no provenance flags. This skill requires Qodo CLI **0.1.0-next.37 or newer**. If older or\nunparseable, do not run `whoami`, `login`, or a review, and do not call it an auth failure. Show\n`qodo update` for the already-recorded public or enterprise origin and ask once before running it.\nAfter an approved update, recheck the version; otherwise stop without changing skill or user files.\n\n## Quick start\nYou just wrote the code, so you hold the one input the reviewer can't get anywhere else: **why**.\nAttach it on every run — write the session context first, then review:\n\n```\nqodo --version                                  # compatibility probe — run this FIRST\nqodo read whoami --json --skill qodo-review --skill-version 1.10.5 --distribution marketplace --host codex\nqodo review --context-file - <<'EOF'         # review local changes vs origin/main, WITH context\n{ \"summary\": \"<what this change does and why>\",\n  \"decisions\": [\"<a choice you made and its rationale>\"] }\nEOF\nqodo review --context-file ctx.json          # same, context from a file\nqodo review --ticket <TICKET_URL> ...        # add a ticket URL (repeatable)\nqodo review --json ...                       # machine-readable findings\nqodo review src/ test/ ...                    # limit to paths (git pathspecs)\nqodo review --base origin/develop ...        # diff against a different base\nqodo review --fast --async --json --context-file ctx.json # coding checkpoint\nqodo review --json --context-file ctx.json               # final review: auto\nqodo review --deep --json --context-file ctx.json        # only for a justified deep review\nqodo review                                  # BARE — only when there is truly nothing to say (rare)\nqodo review status <operation-id>            # collect an --async result (exit 2 = still running)\nqodo review --help                           # exact flags (renders offline)\n```\n\nYou can also keep `.qodo/session-context.json` (same JSON shape) updated at the repo root — it is auto-attached to every run, so even a bare `qodo review` carries your context. An explicit\n`--context-file` overrides it; the file itself is never part of the reviewed diff. Don't commit it\n(add `.qodo/` to `.gitignore` or `.git/info/exclude`).\nAdd `--json` to anything you parse. For connected execution, allow a multi-minute timeout or\nbackground the process; async submission and status collection are separate short calls.\n**Confirm the exact flags with `qodo review --help`** (offline) — the examples here are illustrative.\n\n## Choose execution for the selected review\n\nUse `--async` for coding checkpoints: submit, continue useful work, then collect with `review status`.\nFor a final review, async is also valid, but collect and assess it before the handoff. If live progress\nis useful, read [connected progress](references/connected-progress.md) and use `--json --progress`\nwith a host-native background process. Never combine `--progress` with `--async`.\nA review can take minutes; keep a connected process alive or use async so client exit cannot cancel it.\nIf async is unavailable in the installed CLI, keep the selected depth and use the connected fallback.\n\nFor connected progress, the canonical execution rules are:\n\n- Attach context through a file; stdin heredocs are unsuitable for background execution.\n- Use a unique per-run temporary directory. Separate the single result JSON on stdout from NDJSON\n  progress on stderr. Poll the growing progress file through the host's nonblocking process tools;\n  never run a foreground `tail` that blocks the agent until completion.\n- Relay short status messages, not raw JSON or model output. Translate events by `kind`:\n  `cli.status` gives a readable message; `tool.activity` gives tool name and outcome;\n  `task.delta` and unknown kinds are occasional generic heartbeats, not one message per event.\n- For `qar.client.reconnecting`, relay attempt/delay and structured close/error codes when present.\n  `qar.client.reconnected` means transport opened; `resubscribeAttempts` counts reattached live tasks.\n  `qar.client.reconnect_failed` signals exhausted retries, not the final error explanation.\n- On `task.done`, inspect `payload.status`; on failure/cancellation or `error`, stop progress relay\n  but keep waiting for process exit. Always read the result envelope, including on nonzero exit:\n  actionable messages/hints such as `closed_preview` may appear only there. Progress is not findings.\n- Capture the process exit status, reap the child and disarm its PID before parsing. On interruption,\n  terminate and reap the active child. Clean up only that run's directory on exit/failure/interruption;\n  never reuse or remove a shared `.qodo/review.*` path.\n- If background progress is unavailable, run foreground with a multi-minute timeout, preserving\n  selected depth and context. Missing progress is not a reason to fail review or downgrade depth.\n\n**`qodo: command not found`?** That's PATH, not a missing install: GUI-launched agents (e.g.\nthe Claude Code desktop app) run shells with a minimal PATH. Retry with the absolute path\n`~/.qodo/bin/qodo` (or `$QODO_HOME/bin/qodo` if set) and keep using it for every `qodo`\ncommand here. Only if that file is missing too is qodo actually not installed; tell the\nuser to obtain a checksum-pinned installer command from Qodo or their organization's\nadministrator. Installers are served from https://get.qodo.ai, but never invent a digest\nor pipe an installer directly into a shell.\n\n**Sandbox auth diagnostic.** In a sandboxed environment, if `qodo read whoami` fails for any reason\n(including `Not logged in`), ask the user to approve one exact read-only retry of `qodo read whoami`\noutside the sandbox before recommending login or refreshing tools. Keychain failures can be\nreported as generic auth failures, so the sandboxed result alone is not diagnostic. That approval\napplies only to this single diagnostic retry: do not reuse it, request persistent approval, or move\nlater Qodo commands outside the sandbox automatically. If the retry succeeds, continue with normal\nper-command permission checks. If it still fails, follow the normal auth troubleshooting below.\n\n## Submit and collect with `--async`\n\nCheck support with `qodo review --help`. The following example submits a coding checkpoint. For final\nreview omit `--fast`; add `--deep` only under the selection policy above. Attach the same context in\nall modes. Shell snippets illustrate the CLI protocol; use the host's own nonblocking wait mechanism.\n\n`--async` removes the connection from the critical path. It submits the review over HTTP, prints an\n**operation id**, and exits 0 immediately. The run continues server-side whether or not your process\nis alive; you collect the result later with `qodo review status <operation-id>`.\n\n```\ncommand -v jq >/dev/null 2>&1 || { printf '%s\\n' 'This async recipe requires jq; install it or use the live qodo review flow.' >&2; exit 1; }\nQODO_REVIEW_CONTEXT=\"${QODO_REVIEW_CONTEXT:-.qodo/session-context.json}\"\n[ -f \"$QODO_REVIEW_CONTEXT\" ] || { printf '%s\\n' \"Write the required review context to $QODO_REVIEW_CONTEXT (or set QODO_REVIEW_CONTEXT to its path).\" >&2; exit 1; }\nif ! submission=\"$(qodo review --context-file \"$QODO_REVIEW_CONTEXT\" --async --json --fast)\"; then printf '%s\\n' \"$submission\" >&2; exit 1; fi\nif ! id=\"$(printf '%s\\n' \"$submission\" | jq -er '.operation_id | select(type == \"string\" and length > 0)')\"; then printf '%s\\n' \"$submission\" >&2; exit 1; fi\nqodo review status \"$id\" --json                                # collect it\n```\n\nPoll the existing operation until it finishes; do useful work between status checks. Submission\nexit 0 means accepted, not reviewed. Collection uses these exit codes; read any returned retry delay:\n\n| Exit | Meaning | Do |\n|---|---|---|\n| `0` | Finished. Findings rendered — **identical** output to a live run (`{findings, meta}` under `--json`). | Act on the findings as usual. |\n| `2` | Still running or polling throttled. | Respect `retry_after` when present, then poll the same ID. |\n| `1` | Failed, canceled, expired, or no such operation. Read the `error` envelope. | Follow the bounded recovery below; never assume clean. |\n\n```\n# This collection attempt returns failures to the host for classification under Recover a review.\n# On nonzero exit, preserve the operation ID and emitted error; apply bounded recovery there.\nQODO_REVIEW_TMP=\"$(mktemp -d \"${TMPDIR:-/tmp}/qodo-review.XXXXXX\")\"\ncleanup_qodo_review() { [ -n \"${QODO_REVIEW_TMP:-}\" ] && [ -d \"$QODO_REVIEW_TMP\" ] && rm -r -- \"$QODO_REVIEW_TMP\"; }\ntrap cleanup_qodo_review EXIT; trap 'exit 130' INT; trap 'exit 143' TERM\nwhile :; do\n  status=0; qodo review status \"$id\" --json > \"$QODO_REVIEW_TMP/result.json\" || status=$?\n  case \"$status\" in\n    0) cat \"$QODO_REVIEW_TMP/result.json\" || exit 1; break ;;\n    2) delay=$(jq -r 'if (.retry_after | type) == \"number\" and .retry_after > 0 then .retry_after else 15 end' \"$QODO_REVIEW_TMP/result.json\") || exit 1\n       sleep \"$delay\" ;;\n    *) cat \"$QODO_REVIEW_TMP/result.json\" >&2; exit \"$status\" ;;\n  esac\ndone\n```\n\n**What it costs — know these before you choose it:**\n\n- **No streaming progress.** There are no progress events on this path — the run isn't attached to\n  your process — so `--async` and `--progress` are rejected together rather than emitting a stream\n  that never arrives. There is no intermediate status beyond \"still running\". If the user is\n  watching and wants to see life, use the [connected progress](references/connected-progress.md) recipe instead.\n- **No human-in-the-loop.** This surface runs deterministic agents only; a review that asks for\n  input fails instead of waiting. (`qodo review status` says so and tells you to re-run without\n  `--async`.)\n- **The result is kept for 1 hour** after the review finishes, then it is discarded. Collect it\n  inside that window. Past it, `qodo review status` cannot tell \"expired\" from \"never existed\" or\n  \"belongs to someone else\" — the runtime answers all three identically, on purpose — so it reports\n  all of them. Report the missing review evidence before deciding whether a new run is needed.\n- **Do not assume a new submission is free or deduplicated.** Use `review status` to collect an\n  accepted run. If admission is uncertain, follow the CLI's returned recovery command (on versions\n  that support it, `--async --retry-submission <id>`); never substitute a fresh `qodo review` to poll.\n  Preserve the retained request during recovery instead of gathering the changing working tree again.\n- **Retain the operation id.** It identifies the accepted run; a submission-recovery ID has a different\n  purpose. Do not throw away either handle before collecting or reconciling its outcome.\n\n**The operation id is not the `trace` id.** `qodo` prints a `trace <id>` line on failures — that's\nan OpenTelemetry id for support to diagnose a run with, and it cannot fetch anything. The\n`operation_id` from `--async` is the resumable handle. Don't pass one where the other is wanted.\n\n## Preflight\n\n1. **Auth first.** Run `qodo read whoami`. After the sandbox retry above when applicable, a non-zero\n   exit → tell the user to re-run the exact login command supplied by their installer,\n   organization, or configured endpoint, then stop. With no custom endpoint, use `qodo login`;\n   with an explicit endpoint, preserve it as `qodo login --auth-url <their-url>`. Never replace a\n   custom deployment with the cloud default or invent an endpoint. `Not logged in` /\n   `No tool catalog cached` require login. If `whoami`\n   succeeds but the built-in `qodo review` command is unknown, the runtime is too old; ask the\n   user to update the CLI from the official source. Re-login and catalog refresh cannot add this\n   built-in command.\n2. **Push the base.** The reviewer clones the base commit from the remote, so the base branch\n   (default `origin/main`) must be pushed. If `qodo review` says the base isn't pushed, push it or\n   pass a pushed `--base <ref>`. Your own local changes do NOT need to be committed or pushed —\n   uncommitted edits and untracked new files are included automatically.\n3. **Write your context.** Before running, capture the session narrative — a 2–3 sentence summary\n   of what you changed and why, plus the decisions you made along the way — as the context JSON\n   (stdin heredoc, a file, or `.qodo/session-context.json`). You always have this: you just wrote\n   the code. Run bare only when there is genuinely nothing to say.\n\n## What gets reviewed\n\n`qodo review` gathers, all client-side:\n\n- The **tracked diff** vs the base, plus **new/untracked files** (secrets, binaries, oversized,\n  and gitignored files are filtered out and reported — never silently dropped).\n- The **branch name**, **HEAD commit**, and a **description** synthesized from your commit messages.\n- Any **ticket refs** and **session context** you attach (below).\n\n`--json` returns `findings` from this call, with optional `meta` and `finding_state` on newer engines.\nFor repeated reviews, read `finding_state.introduced` **and** `.still_open`; an empty `findings`\narray alone does not mean clean. `.resolved` records detected fixes; `.dismissed` preserves dismissals.\nIf `finding_state.complete` or `meta.coverage.complete` is false, report the incomplete coverage.\n\n`meta.analysis.mode` is `full`, `incremental`, or `reused`. Reused means the same reviewed snapshot\nand compatible context; earlier open findings remain open. The CLI privately saves the submitted patch.\nIt advances its checkpoint after collecting an eligible result, including via `review status`.\nFailed or older completions cannot replace a newer checkpoint.\nKeep the same base, path scope, requested depth mode and context during a fix loop. Changed context, expired or\nunverifiable checkpoints, and unsupported deltas fall back to full review. Never fabricate a checkpoint.\nFor a deliberately fresh assessment use `--full` (confirm support with `--help`). It controls scope,\nnot depth; it is not needed on every fix. Changing the requested depth mode invalidates compatible\ncheckpoint coverage. Auto does not promise a fixed effective tier; rely on returned analysis/coverage.\nOlder engines omit these fields: use their findings and coverage without claiming reuse.\n`meta.reviewers.ran` / `.skipped`, `meta.depth`, and `meta.safety_net.reinjected` describe coverage.\nA reused result has no new reviewer execution. Attach missing input for a material skipped dimension.\nNever remove context merely to make an incremental checkpoint eligible.\n\n## Attach coding-session context (this is the point)\n\nAttach the intent and decisions behind your change. Three channels:\n\n- `--ticket <url>` — a ticket/issue URL (repeat for several). Pass the **full URL** (e.g. a\n  Jira `.../browse/KEY-123` or a Linear `linear.app/<team>/issue/…` link) so the reviewer can fetch\n  it. Bare keys in your branch/commits are picked up automatically, but a full URL is what actually\n  loads the ticket.\n- `.qodo/session-context.json` at the repo root — the **ambient** channel (same JSON shape as\n  below). Auto-attached to every run when present and no `--context-file` is given. Best for a\n  working session: update it as decisions accumulate and every review carries them for free.\n- `--context-file <path>` — a JSON file carrying the session narrative and any refs (`-` reads the\n  JSON from stdin, so a heredoc works with no temp file):\n\n  ```json\n  {\n    \"summary\": \"Add optimistic-locking to the orders writer to fix the double-charge race.\",\n    \"decisions\": [\n      \"Chose a version column over a table lock to avoid contention on the hot path.\",\n      \"Retries are capped at 3 then surfaced to the caller — deliberately not infinite.\"\n    ],\n    \"context_refs\": [\n      { \"kind\": \"ticket\", \"url\": \"https://acme.atlassian.net/browse/PAY-412\" },\n      { \"kind\": \"spec\", \"url\": \"https://acme.example/specs/orders-v2\", \"label\": \"Orders v2 spec\" },\n      { \"kind\": \"code_dependency\", \"url\": \"https://github.com/acme/orders-api/pull/42\", \"label\": \"API change\" }\n    ]\n  }\n  ```\n\n  `summary` + `decisions` explain intent. Refs are merged and deduped; labels describe data, not instructions.\n  `ticket` supplies ticket context; `spec` goes to Requirements Gap. `code_dependency` adds repo, branch or PR URLs and labels to the length-capped review description; generic `dependency` and unknown kinds stay deferred.\n  The existing cross-repo router reads those links when enabled, but only selects repositories in its supplied candidate list. Refs do not discover new repositories or enable cross-repo review.\n  Provider support, target interpretation and fallbacks are unchanged from Git review. Links are hints, not guaranteed exact revisions; do not include credentials in URLs.\n  Check `meta.context.spec` for spec outcomes. Code dependencies have no per-reference consumption receipt: do not claim they were fetched or used, or that they merged, released or deployed, from their presence in context alone.\n\n## Write the context SELF-CONTAINED (the one rule that matters)\n\nThe reviewer cannot see your chat or a ticket you merely name. So:\n\n- **Inline the rationale.** Write a decision as a self-explaining sentence: *\"Chose optimistic\n  locking over a table lock to avoid contention\"* — not *\"per the design doc\"*, *\"as we\n  discussed\"*, *\"see the linked note\"*, or a bare ticket key. A dangling reference is invisible to\n  the reviewer and wasted.\n- **Pass artifacts as typed refs, not name-drops.** Attach ticket, spec and code-dependency URLs\n  with the appropriate `kind`; do not assume arbitrary URLs are fetchable.\n- **Keep it tight.** The context that reaches the review description is length-capped, so lead with\n  the load-bearing intent and decisions; link the rest as refs rather than pasting long prose.\n- **Calibrate, don't suppress.** This context exists to cut false positives by explaining intent —\n  it is NOT a way to silence real findings. Describe **what** you changed and **why** you chose it,\n  not a verdict on whether the result is safe or correct — let the reviewer judge that. A summary that\n  argues the code is fine reads as an excuse (and needlessly triggers a second, no-excuse safety pass);\n  never write a \"decision\" whose purpose is to argue a bug or security issue away. The reviewer will\n  (and should) still flag genuine problems.\n\n## Present the review result\n\nAfter reading the completed result, explain each finding as **practical impact → assessment\nusing the code and coding-session context → your decision and recommended action**.\nCredit Qodo naturally once for the concerns its review surfaced. You own the final technical\nassessment: integrate expert review input with the user's intent, decisions, and constraints.\nExplain what could happen, under which conditions, and which behavior is affected; connect that\nimpact to the change the user requested. Do not invent production conditions or affected users.\nFor example: “Qodo identified [risk]. Given our decision to [intent/constraint] and [code\nevidence], I recommend [action] because [reason].” Adapt the wording to the actual evidence.\n\nKeep each issue's explanation coherent, cite supporting code, and preserve its reference and\nreported category/level separately from your recommendation. Group overlapping findings only\nwhen all references remain visible and individually selectable. Use short impact-based titles\nor lists when useful; no branded headings, emoji banners, slogans, footers, or repeated summaries.\nReport only known counts and coverage. Lead with material skipped/failed reviewers or incomplete\ncoverage; zero findings alone is not a clean verdict. A complete review with no findings can be\none sentence. For gated/failed runs, report the actual limitation rather than a completed result.\n\n## Act on the findings\n\nIndependently evaluate every finding and own its disposition and rationale: **fix** a supported\nissue (your fix may differ from Qodo's suggestion), **dismiss** an unsupported concern with code\nevidence, or **investigate** uncertainty by naming the check needed. A session decision supports\ndismissal only when the code enforces its assumptions. Keep the tone collaborative and factual;\ndo not routinely qualify Qodo's capability or turn a wrong finding into a broader judgment.\nYour technical recommendation does not grant edit permission: follow the approval gate below.\n\n**Present and ask (default).** Use the assessment above for every finding, keeping its\n`[category/level]` and your recommendation, then ask **in a single prompt** which findings to apply. Use whatever the\nhost gives you: a multi-select if it has one (Claude Code's `AskUserQuestion`, say), otherwise a\nnumbered list and \"reply with the numbers to apply\". One prompt either way — don't ask per finding.\n**Nothing is pre-selected.** Mark which ones you recommend, but the user must actively choose: this\nprompt is the last thing standing between a finding and an edit, so a bare Enter must apply nothing.\nApply only what the user picks (edit as normal, matching the surrounding style); report the rest as\nskipped with your reason. Do not edit any code before the user has chosen.\n\n**Autofix (skip the gate).** Only an **explicit `autofix` token** in the invocation (e.g.\n`qodo-review autofix`) skips the prompt outright. Phrasing that merely sounds like opting in (\"just\nfix them\", \"don't ask me\") is not enough by itself — reading intent wrong here edits code the user\nnever approved, which is the exact failure this gate exists to prevent. On inferred intent, name the\nexact scope you'd apply and get one confirmation — \"Reading that as autofix — apply the N fixes I\nrecommended?\" — not \"all N\", which reads as the whole set and widens scope on the very ambiguity\nthis check exists to catch. Either way apply exactly what the evaluation decided and nothing beyond\nit (fix the sound ones; skip the wrong/deliberate ones with a reason), and report what you applied\nand what you skipped.\n\nWhen the user explicitly authorizes declining a local finding, follow\n[Record local triage](references/local-triage.md) to persist the decision. A conversational\n\"skip\" alone is not a stored dismissal and must not be reported as one.\n\nAfter a batch of authorized fixes, verify and re-review changed work using the lifecycle policy above.\nAssess outstanding findings and coverage before calling the result clean; stop an unproductive loop.\nCommit/push per the user's workflow — ask before pushing unless they've told you to.\n\n## Recover a review\n\nFor an accepted async run, collect by operation ID even if the submit process exited. On a status\ntransport error, retry collection of the same ID at most once after the returned retry delay\n(or 15 seconds if absent). If collection still fails, preserve the ID for later recovery and report\nthe coverage gap; do not submit again or keep polling automatically. The polling example returns\nnonzero errors to the host for this classification and bounded recovery. On a confirmed terminal failure,\nread the error and correct a recoverable cause before retrying at most once, with the selected\nmode and context preserved. Honor entitlement, auth, permission and rate-limit stops; do not retry\nthose as transient failures. Further failure or an expired/unavailable result means reporting the\ncoverage gap; never claim completion or silently keep buying retries.\n\nThe following connection rules apply to connected execution, not an accepted `--async` run. A review can take\nminutes; if the host cannot keep a process alive, choose async rather than repeatedly timing out.\n\n- **Keep the run alive and connected for its whole duration.** The CLI holds a streaming\n  connection to the review; the server keeps a run whose client vanished for only a short grace\n  window before cancelling it. So a harness that times out and kills the CLI kills the review —\n  not instantly, but a couple of minutes later, which is why the cancel can look like it came out\n  of nowhere. Background the run rather than foregrounding it under a tool timeout; use the\n  [connected progress](references/connected-progress.md) recipe, and backgrounding is also what lets you stream\n  status.\n\n**Concurrent reviews can complete independently.** For the same owner/repository/branch, only the\nnewest checkpoint run can publish finding updates; an older result may report `superseded`.\n\nThe failure shapes are distinct, so read which one you got instead of guessing:\n\n- **No output, the process died** → your side killed it (tool timeout, SIGTERM, Ctrl-C). The\n  server-side run does not stop with it; it is cancelled a short while later, so this and the\n  cancel below are often the same incident seen from two ends.\n- **`review canceled by the server …`** → the server ended the run. When it says the connection\n  dropped, that's the cause: the CLI lost its stream and did not get back in time. Not a size,\n  complexity, or concurrency limit.\n- **`review ended without a result (no task.done)`** → the stream dropped mid-run.\n- **`review failed: <detail>`** → a real backend failure; the detail says what.\n\nFor the first three, collect any retained result using the CLI's recovery hint before submitting again.\nIf the run is confirmed canceled or unrecoverable, retry at most once with uninterrupted execution\nand the same selected depth/context. A pending run is not a reason to restart. Further failure means\nreporting incomplete review, not looping, dropping context or downgrading depth to obtain a result.\n\n## If the run is gated: closed preview\n\n`qodo review` is currently in **closed preview** — the server rejects runs from organizations that\naren't enrolled. A gated run exits non-zero with a stable machine-readable error: `--json` emits\n`{\"error\": {\"code\": \"closed_preview\", \"message\": ..., \"hint\": ...}}`; without `--json` the same\nmessage and hint print as prose.\n\nOn `closed_preview`:\n\n1. **Surface the `message` and `hint` to the user unchanged** (don't paraphrase or truncate;\n   the `--json` payload carries them verbatim, while the CLI's prose output strips terminal\n   control characters), then\n2. **STOP.** The gate is an entitlement, not a transient fault — retrying, backing off, watching,\n   or looping **cannot** succeed until the user's organization is enrolled. Do not re-run\n   `qodo review` unless the user says enrollment happened (after enrollment, access activates\n   within ~10 minutes; no re-login needed).\n\nOnly the review itself is gated — auth (`qodo read whoami`) and the other qodo commands are unaffected.\n\n## Configuration\n\nUse `--fast --async --json` for coding checkpoints, auto for ordinary final review,\nand `--deep` only under the stated exceptions. Use `--json --progress` for connected progress and\nan explicit `--base` when origin/main is not correct. Stamp exact skill/version/distribution provenance\non the first Qodo call after the unadorned version probe and keep session context out of the reviewed diff.\n\n## Error Handling\n\nRead the structured result even after a non-zero command. Preserve closed-preview, cancellation,\nrate-limit, connection, and tool-loop states; follow the bounded recovery above and never discard\ncontext or widen authority merely to obtain a green result.\n\n## Guardrails\n\n- **Local scope.** Review coding milestones and local work before PR/update or completed-work handoff.\n  Use `qodo-review-resolver` for findings already posted on a PR; avoid duplicate unchanged reviews.\n- **No forge writes.** `qodo review` reads your local diff and returns findings; it never pushes,\n  comments, or opens a PR. Resolving a finding means editing code, not posting anywhere.\n- **The base must be pushed;** your local work need not be. New/untracked files are reviewed by\n  default; secrets/binaries/oversized/gitignored files are filtered and reported.\n- **Don't guess creds or the base** — resolve auth first, and pass `--base` when it isn't\n  `origin/main`.\n- **Collect every run.** Background connected runs or use async; preserve recovery handles.\n  A superseded result does not advance the incremental baseline or certify current code.\n- **Never strip context to beat the clock.** Dropping `--context-file` doesn't make a run faster —\n  it just buys a worse review. Give it time; choose depth by lifecycle, never by timeout pressure.\n- An `MT-TOOL-LOOP` or `MT-RATE-LIMITED` error means stop/back off and change approach, not retry.\n- A `closed_preview` error means the org isn't enrolled in the preview — surface message + hint to\n  the user and stop; never retry or loop on it (see \"If the run is gated\" above).\n\nAfter authorized fixes, report what changed, how it was verified, and what remains with reasons.\n"
}