docs(cli): record the blast-radius reason for the guard, not a false one

Contract review drove `dependsOn` rather than reading the report, and the
recorded reason was partly false. The choice is unchanged; only the reason is.

Two corrections, both comment-only:

  * `dependsOn` CAN be brought inside this command's envelope — a `catch()`
    override on the parse answers exit 1 with `{error}` on the `--json` face
    and an empty stderr. "The framework spelling cannot be enveloped" was the
    sentence the guard leaned on, and it is not true. The real objection is
    scope: that override re-shapes EVERY parse error on this command — every
    unknown flag and bad value moving from exit 2/stderr to exit 1/stdout,
    carrying oclif's prose and its `--help` hint inside the JSON `error`
    string — where the guard moves one invocation class and leaves the rest.

  * The stack trace beside oclif's refusal is a DEV-ENTRY artefact of
    `settings.debug` on `bin/run-dev.js`; the shipped `bin/run.js` prints the
    pretty message with no stack. The old comment generalised the dev entry.

The test header carried the same false claim and said these pins "fail that
implementation" — a `catch()` override passes them. It now says so, and says
a green here is not a verdict on the choice. No assertion is touched: the
`expect(` count is 18 before and after, and the diff is comment lines only.

Behaviour, pins and changeset are unchanged.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01D47qPfEWVPmhguWgBZCi5N

Author: claude

packages/cli/src/commands/lint.ts

@@ -541,14 +541,29 @@ export default class Lint extends Command {
     // flag, so dropping the claim documents a no-op flag instead of removing
     // one, and blesses the silent acceptance rather than ending it.
     //
-    // ⛔ NOT oclif's `dependsOn: ['eval']`, and that is measured rather than
-    // assumed. It does refuse — but it refuses in the PARSER, before the
-    // command runs, so the refusal is oclif's and not this command's: exit 2, a
-    // stack trace on stderr, and under `--json` an EMPTY STDOUT (measured, both
-    // faces). A machine consumer of `os lint --json` would get no JSON document
-    // at all — the off-envelope class #15549/#16044 had just repaired one exit
-    // over on this very command. Refusing here keeps the envelope this command
-    // already answers with: the human message on `error`, exit 1, both faces.
+    // ⛔ NOT oclif's `dependsOn: ['eval']` — and the reason is BLAST RADIUS,
+    // not an inability to answer inside this command's envelope.
+    //
+    // Bare `dependsOn` refuses in the PARSER, before the command runs, so its
+    // refusal is oclif's: exit 2, and under `--json` an EMPTY STDOUT. (The
+    // stack trace that accompanies it on `bin/run-dev.js` is a DEV-ENTRY
+    // artefact of `settings.debug`; the shipped `bin/run.js` prints oclif's
+    // pretty message with no stack. Don't generalise the dev entry's output.)
+    //
+    // ⚠️ That much CAN be brought inside the envelope: a `catch()` override on
+    // the parse was measured answering exit 1 with `{error}` on the `--json`
+    // face and an empty stderr. So "the framework spelling cannot be
+    // enveloped" is FALSE, and ⛔ nobody should re-derive this choice from it.
+    //
+    // The real objection is scope. That override re-shapes EVERY parse error on
+    // this command, not the one precondition this card is about: every unknown
+    // flag and every bad value would move from exit 2 / stderr to exit 1 /
+    // stdout, and would carry oclif's own prose plus its `--help` hint inside
+    // the JSON `error` string — a wide, uncommissioned change to the very
+    // `--json` envelope #15549/#16044 had just repaired one exit over. A guard
+    // here moves ONE invocation class and leaves every other parse error
+    // exactly as it was, while keeping the envelope this command already
+    // answers with: the human message on `error`, exit 1, both faces.
     //
     // ⛔ Nor the raw-argv guard `os migrate meta` uses for its stored-only
     // flags. That one exists because oclif reads a `default: false` boolean and

packages/cli/test/lint-generator-requires-eval.e2e.test.ts

@@ -36,10 +36,14 @@
  * set is exactly `error`. A later edit that invents a code for it goes red here
  * rather than handing consumers a vocabulary no ledger declares.
  *
- * ⛔ The refusal is deliberately NOT oclif's `dependsOn: ['eval']`. Measured on
- * this entry: `dependsOn` refuses in the parser with exit 2, a stack trace on
- * stderr, and EMPTY STDOUT under `--json`. `the --json face stays a machine
- * face` and the exit-code assertions fail that implementation.
+ * ⛔ The refusal is deliberately NOT oclif's `dependsOn: ['eval']` — and these
+ * pins are NOT the argument for that. Bare `dependsOn` does fail them (exit 2,
+ * empty stdout under `--json`, measured), but a `catch()` override brings it
+ * inside the envelope and PASSES them. So a green here is not a verdict on the
+ * choice, and ⛔ must not be read as one. The reason the guard lives in the
+ * command is BLAST RADIUS — that override re-shapes every parse error on this
+ * command rather than this one precondition — and it is recorded where the
+ * decision is, at the guard in `src/commands/lint.ts`.
  *
  * ## Why no `dist/` sits on the measured path
  *