oh-my-opencode 4.5.1 → 4.6.0

package/packages/omo-codex/plugin/skills/debugging/references/methodology/02-investigate.md

@@ -0,0 +1,130 @@
+# Phase 2 + 3 — Hypothesis Formation & Parallel Investigation
+
+One hypothesis is a hunch. Three hypotheses is a decision. Investigation is how you turn the decision into runtime evidence.
+
+---
+
+## Phase 2 — Hypothesis Formation (Minimum Three)
+
+### Why three, not one
+
+A single hypothesis creates confirmation bias: you'll read runtime state looking for evidence that confirms it and unconsciously discount contradictions. Three hypotheses force you to design queries that *distinguish* between them, which is the only way runtime evidence becomes decisive.
+
+### Generate across orthogonal axes
+
+If your three hypotheses are all variations of "the handler has a bug", you don't actually have three hypotheses. Span the space:
+
+| Axis | Example framing |
+|---|---|
+| **User-code logic** | "The handler early-returns because condition X is unexpectedly true" |
+| **Library/SDK behavior** | "The third-party client swallows the error and returns a stub" |
+| **Environment/config** | "The env var is read at module-load time before it gets populated, so it's empty" |
+| **Async/timing** | "The promise rejects (or goroutine panics) after the response is already sent" |
+| **Silent side-effect** | "An earlier turn mutated shared state that the current turn inherits" |
+| **Observability gap** | "The error is raised but suppressed before logging; it only exists as an unawaited rejection / ignored signal" |
+| **Binary-level** (when applicable) | "The function we think is running is actually jumped over by a patched thunk / a different version loaded" |
+| **Build-vs-runtime** | "The code we're reading is not the code that's running — stale build, wrong symlink, cached wheel, or dist/ ahead of src/" |
+
+### For each hypothesis, write in the journal
+
+1. **Claim** — one sentence.
+2. **Distinguishing evidence** — the exact value or state that confirms or refutes it, AND where to read it (file:line, log source, breakpoint location, memory address).
+3. **If true, the fix is** — two words. Forces you to think through fix cost before committing to the hunt.
+
+### Collapse rule
+
+If two hypotheses have identical distinguishing evidence, they aren't actually different — collapse them and find a real alternative. If you can't come up with a third distinct hypothesis, you don't understand the system well enough yet. Go read a little more code before investigating.
+
+---
+
+## Phase 3 — Parallel Investigation
+
+Branch depending on what's available.
+
+### Path A: Team mode ENABLED
+
+When the `team_*` tools are present, create a **debug-squad** team and split investigation across members working on different evidence sources. This is the right default whenever you have ≥3 hypotheses and any of them would take >10 minutes to investigate single-threaded.
+
+**Team spec** — write to `~/.omo/teams/debug-squad/config.json`:
+
+```json
+{
+  "name": "debug-squad",
+  "lead": { "kind": "subagent_type", "subagent_type": "sisyphus" },
+  "members": [
+    {
+      "kind": "category",
+      "category": "deep",
+      "prompt": "You are the Runtime State Inspector. Your job: attach to the live process, hit breakpoints, read program state (variables, heap, goroutines, stack, registers depending on runtime), and report observed values verbatim. Never guess — if you don't see the value, say so. Report back via team_send_message with file:line / address references and captured values. Never edit source code. Never run git commands. If you need an instrumentation statement added (breakpoint(), debugger;, dbg!, etc.), ask the Lead first."
+    },
+    {
+      "kind": "category",
+      "category": "deep",
+      "prompt": "You are the Log Archaeologist. Your job: grep server logs, stderr streams, SDK-internal debug output (DEBUG env, RUST_LOG, GODEBUG, PYTHONASYNCIODEBUG), and correlate timestamps. Produce a timeline of events with latencies. Flag anything that looks like a silent catch, a swallowed rejection, a panic recovered-and-ignored, a success response that contains failure signals (HTTP 200 with empty body, stopReason=error, exit 0 with error-in-stdout). Never edit source code."
+    },
+    {
+      "kind": "category",
+      "category": "deep",
+      "prompt": "You are the Reproduction Engineer. Your job: build the smallest reliable repro — a curl command, a vitest/pytest/go test, a tmux script, a Playwright script for browser bugs, a pwntools script for binary targets. It must reproduce on first try and be copy-pasteable by the Lead. Document exact input, expected output, observed output. Save repro artifacts under /tmp/ and tell the Lead to journal them. If the bug is browser-based you MUST use Playwright CLI — do not simulate with curl."
+    },
+    {
+      "kind": "category",
+      "category": "deep",
+      "prompt": "You are the Trace Correlator. Your job: take findings from the other members and cross-link them. Build a causal chain from symptom to suspected cause. Identify missing evidence. Propose the next single most-decisive runtime query. Never edit source code; only reason across already-captured evidence. If hypotheses diverge sharply after correlation, tell the Lead immediately — that is the signal for the Oracle Triple."
+    }
+  ]
+}
+```
+
+**Assignment rule**: one hypothesis → one `team_task_create`. Give each hypothesis to the member whose evidence source is most likely to confirm or refute it. Broadcast the full hypothesis list once via `team_send_message(to="*")` so members know what the others are testing.
+
+**Lead responsibilities**:
+- Maintain the journal (members do not write to it).
+- Approve any source-code edits (including `debugger;` / `breakpoint()` / `dbg!` statements).
+- Synthesize member reports into updated hypothesis statuses.
+- Decide when to disband: `team_shutdown_request` → `team_approve_shutdown` → `team_delete`.
+
+**Team does NOT include Oracle** — Oracle is a hard-reject team member type. Oracle is used separately in Phase 4 (see `04-oracle-triple.md`).
+
+### Path B: Team mode DISABLED
+
+Fan out async explore/deep subagents instead. Same rule: one hypothesis per subagent.
+
+```
+task(subagent_type="explore", load_skills=[], run_in_background=true,
+     prompt="[CONTEXT: bug summary + which hypothesis you own + what state to look at]
+     Runtime state investigation for hypothesis 1: ...")
+task(subagent_type="explore", load_skills=[], run_in_background=true,
+     prompt="Log/timing investigation for hypothesis 2: ...")
+task(category="deep", load_skills=[], run_in_background=true,
+     prompt="Reproduction minimizer for hypothesis 3: ...")
+```
+
+End your response, wait for completion notifications, then synthesize.
+
+---
+
+## Evidence capture discipline (both paths)
+
+For every piece of runtime state captured, record in the journal:
+
+```markdown
+### <ISO timestamp> — <what you looked at>
+- Source: <file:line | log source | curl command | breakpoint address>
+- Value: `<verbatim>`
+- Interpretation: <one line — why this matters>
+- Refutes/Confirms: H<n>
+```
+
+**Verbatim values only. No paraphrasing.**
+
+- `messages.length=0` is evidence.
+- "messages seemed empty" is not evidence — it's a memory of an observation, and memory of observations is where debug sessions go to die.
+
+If you find yourself about to paraphrase, stop, go back, and copy the raw value.
+
+---
+
+## Round completion
+
+A "round" is complete when every hypothesis has either confirming or refuting evidence — or when you have exhausted the evidence sources available without a decisive result. If the round ends inconclusively, that counts as a failed round for the counter in the journal. See `04-oracle-triple.md` for what to do at 2 consecutive failed rounds.

package/packages/omo-codex/plugin/skills/debugging/references/methodology/04-oracle-triple.md

@@ -0,0 +1,136 @@
+# Phase 4 — Oracle Triple Consultation
+
+At 2 consecutive failed hypothesis rounds, stop investigating and reframe. Continuing past two failures usually means the real cause is in a category you haven't imagined — and more time on your current mental model is wasted time.
+
+The Oracle Triple is how you break out of the mental box.
+
+> ⚠️ **Wrong tool for non-debugging tasks.** The Triple is for *stuck root-cause hunts*. If your task is producing an artifact (extraction, reverse engineering, audit, compliance documentation) and you want a skeptical review before declaring it done, use the **Verification Oracle** pattern in [partial-runtime-evidence.md](partial-runtime-evidence.md#verification-oracle-pattern-for-non-debug-tasks). Running the Triple on a finished extraction returns three diverging "what if you tried…" tangents that are not what you need.
+
+---
+
+## When to invoke
+
+| Situation | Invoke? |
+|---|---|
+| 1 round failed, you have new distinguishing evidence | No — run one more round with a refined hypothesis set |
+| 2 rounds failed, hypotheses now feel like variations of each other | **Yes — invoke now** |
+| 2 rounds failed, no new evidence angles left to try | **Yes — invoke now** |
+| You've been investigating >2 hours on the same bug | **Yes — invoke now regardless of round count** |
+| 1 round failed but the user is watching and wants speed | No — one round isn't enough to justify Oracle cost. Resist the urge. |
+
+---
+
+## Why three Oracles, and why *orthogonal* framings
+
+A single Oracle call returns a single coherent analysis. Coherent analyses tend to inherit the framing of the prompt, which means they inherit the same blind spots the investigator already has. Three Oracles with *orthogonal framings* force the analyses to diverge, and the places where they agree across frames is where the real signal lives.
+
+The three framings below are chosen to cover distinct bug-cause categories:
+
+- **A (obvious-but-missed)** — embarrassingly simple causes the investigator walked past.
+- **B (system-boundary)** — causes living at integration seams, not in the code being read.
+- **C (invariant-violation)** — assumptions load-bearing to current hypotheses that may themselves be false.
+
+Spawn all three in parallel.
+
+---
+
+## The three prompts
+
+```
+task(subagent_type="oracle", load_skills=[], run_in_background=true,
+     prompt="[CONTEXT: bug description + evidence captured so far, verbatim, with file:line refs]
+
+     Framing A — OBVIOUS-BUT-MISSED.
+     What is the most embarrassing, most obvious cause that a senior engineer would spot in 30 seconds and we've overlooked? Consider:
+     - typos, off-by-one
+     - wrong variable name / wrong constant / wrong import
+     - stale cache, wrong file edited, wrong process inspected
+     - attached to the wrong instance of the service
+     - test harness running different code than the app
+     - editing src/ while running dist/
+     
+     Give me exactly three candidate causes ranked by likelihood, with one sentence each explaining why our evidence is consistent with each.")
+
+task(subagent_type="oracle", load_skills=[], run_in_background=true,
+     prompt="[CONTEXT: bug description + evidence captured so far]
+
+     Framing B — SYSTEM-BOUNDARY.
+     What if the bug is NOT in the code we've been reading, but at a boundary? Consider:
+     - third-party SDK behavior that contradicts its docs
+     - middleware that mutates the request or response
+     - a proxy/gateway/load balancer that rewrites headers or bodies
+     - build-time vs runtime env-var resolution
+     - module-load-order issue
+     - shared-library version mismatch (system lib vs bundled lib)
+     - ABI difference (native addons, glibc versions, musl vs glibc)
+     - wrong transport (HTTP/1.1 vs HTTP/2, TLS version negotiation)
+     
+     Give me three candidate causes, each naming the specific boundary and the specific contract assumption that might be violated.")
+
+task(subagent_type="oracle", load_skills=[], run_in_background=true,
+     prompt="[CONTEXT: bug description + evidence captured so far]
+
+     Framing C — INVARIANT-VIOLATION.
+     Which invariants that we've been ASSUMING TRUE might actually be false?
+     Enumerate the five assumptions most load-bearing to our current hypotheses, then for each:
+     - describe the smallest runtime query that would falsify it
+     - predict what the observable would be if the invariant holds vs if it fails
+     
+     We want at least one of these queries to be decisive.")
+```
+
+---
+
+## Synthesizing across three Oracles
+
+**Do not pick the highest-ranked candidate from a single Oracle.** That defeats the purpose of getting three framings.
+
+Instead, walk the outputs in this order:
+
+### 1. Agreement scan
+
+Note which candidate causes appear in at least two Oracles' outputs. Independent agreement across orthogonal framings is strong signal — when the obvious-but-missed framing and the system-boundary framing both land on the same cause, that's usually the bug.
+
+### 2. Disagreement scan
+
+Note where Oracles disagree. Disagreement is genuine uncertainty that runtime evidence (not more reasoning) must resolve. Each disagreement becomes a candidate for the next round's distinguishing query.
+
+### 3. New falsification queries
+
+Framing C produces concrete "one query that would decide it" suggestions. Pull these verbatim into your new round's evidence-gathering plan — they are designed to be decisive.
+
+### 4. Build the new hypothesis set
+
+Minimum 3, same rules as Phase 2. Aim to have hypotheses drawn from the agreement scan (likely cause) AND from the disagreement scan (so one round's evidence resolves the disagreement).
+
+Record in the journal:
+
+```markdown
+## Oracle Triple — Round <N>
+- Invoked at: <ISO timestamp>
+- Framing A summary: <top 3 candidates, one line each>
+- Framing B summary: <top 3 candidates>
+- Framing C summary: <5 load-bearing assumptions + falsification queries>
+
+### Cross-framing agreement
+- <candidate> appeared in A + B
+- <candidate> appeared in B + C
+
+### New hypothesis set
+1. <hypothesis> — evidence to gather: <one-liner>
+2. ...
+```
+
+### 5. Reset the counter
+
+Reset the "consecutive failed rounds" counter to 0. Return to Phase 3 (parallel investigation) with the new set.
+
+---
+
+## If *another* 2 rounds fail after the Oracle Triple
+
+You are genuinely stuck. This is the escalation threshold.
+
+Escalate to the user (see `05-escalate.md`) with the full trace: every hypothesis tried, every piece of evidence captured, both Oracle syntheses. Do not guess a fix.
+
+This is rare — in practice, the Oracle Triple resolves almost all stuck debugging sessions within one round, because it pulls in framings the investigator was too close to the code to see.

package/packages/omo-codex/plugin/skills/debugging/references/methodology/05-escalate.md

@@ -0,0 +1,69 @@
+# Phase 5 — User Decision Escalation
+
+Escalation is for genuine ambiguity, not for skipping investigation. Most "should I ask the user" moments are really "I don't want to do one more query" moments, and those are wrong.
+
+---
+
+## Ask the user ONLY when
+
+- **Evidence exhausted**, contradictions remain, and further investigation would require a decision with policy implications (e.g. "patch the third-party SDK vs wrap it vs change architecture").
+- The bug has **multiple valid fixes with different scope/risk tradeoffs** and the user's preference drives the choice.
+- A proposed fix would **change observable product behavior** for the end user (not just fix the internal bug).
+- You've **exhausted the Oracle Triple** and another 2 rounds failed after synthesis.
+
+## Do NOT ask when
+
+- You haven't tried the Oracle Triple yet.
+- The question can be answered by one more runtime query.
+- You're asking for permission to do the obvious thing.
+- You're asking because you're tired.
+
+---
+
+## Escalation format (paste into the reply)
+
+Keep it short. Evidence-dense. One decision, not a status update.
+
+```markdown
+## Decision needed
+
+**What we know** (verbatim evidence, not paraphrase):
+- <fact 1 with file:line or address>
+- <fact 2 with source>
+- <what the evidence rules IN>
+- <what the evidence rules OUT>
+
+**What the decision is** (one sentence):
+<the fork in the road>
+
+**Options**:
+
+| # | Fix | Scope | Risk | Effort |
+|---|-----|-------|------|--------|
+| A | <short label> | <files touched / layers> | <regressions possible> | <rough> |
+| B | ... | ... | ... | ... |
+| C | ... | ... | ... | ... |
+
+**Recommendation**: <A/B/C> because <one-sentence reason>.
+
+Which direction do you want?
+```
+
+---
+
+## Anti-patterns in escalation
+
+- **Asking without evidence.** "What do you want me to do?" is not an escalation, it's abandonment. Every escalation includes the evidence the user needs to decide.
+- **Two questions in one.** One decision per escalation. Multi-part questions lead to partial answers and re-escalation.
+- **Escalating before Phase 4.** If you haven't tried the Oracle Triple, you haven't earned the right to escalate.
+- **Presenting options you don't actually have.** If option C requires a library the user doesn't use, don't list it. The options are only things you can actually do today.
+- **Hiding a recommendation.** The user hired you to think — always end with a recommendation, even if you're low-confidence. Say so explicitly: "Recommendation (low confidence): B, because X. If you have context about Y that I don't, it might change to A."
+
+---
+
+## What happens after the user responds
+
+- **User picks an option**: return to Phase 6 (root cause confirmation) with the chosen direction. The user's choice is not itself confirmation — you still need runtime evidence that the cause you're fixing is the cause in play.
+- **User proposes a different option you hadn't considered**: treat it as new information. Update hypotheses. May trigger another Phase 3 round.
+- **User gives more context that resolves the disagreement**: skip to Phase 6.
+- **User is also unsure**: that's a signal you need more evidence, not more opinions. Run one more targeted query before asking again.

package/packages/omo-codex/plugin/skills/debugging/references/methodology/06-fix.md

@@ -0,0 +1,116 @@
+# Phase 6 + 7 — Root Cause Confirmation & TDD Fix
+
+A cause is not "confirmed" until you can toggle the bug by toggling the cause. Every other level of evidence is correlation, and correlation-driven fixes ship bugs.
+
+---
+
+## Phase 6 — Root Cause Confirmation
+
+You are allowed to call the cause "confirmed" only when ALL THREE of these hold:
+
+### 1. Captured runtime value matches the hypothesis exactly
+
+Not "the value looks consistent with" — the value is exactly the value the hypothesis predicted. If your hypothesis was "baseUrl is api.anthropic.com despite ANTHROPIC_BASE_URL being set to a proxy", the captured value is literally `"https://api.anthropic.com"` in the debugger at the moment of the HTTP call.
+
+### 2. Reproducible
+
+Running the repro a second time yields the same observation. Flaky repros mean you haven't isolated the cause; you've isolated a symptom that sometimes appears when the cause does. Keep investigating.
+
+### 3. Toggle proof (the one most skipped)
+
+**Changing the value** (via debugger assignment, env override, or a speculative one-line patch) **makes the bug disappear — and reverting brings the bug back**.
+
+If you can't toggle the bug by toggling the suspected cause, what you have is a correlation, not a mechanism. A correlation is a strong hypothesis, not a confirmed cause.
+
+Examples of a valid toggle proof:
+
+| Suspected cause | Toggle |
+|---|---|
+| Env var overrides library default, and the override is wrong | Unset the env var → bug goes away. Reset it → bug comes back. |
+| Async task is not awaited | Add `await` → bug goes away. Remove `await` → bug comes back. |
+| Third-party SDK uses hardcoded URL | Monkey-patch SDK to use env URL → bug goes away. Unpatch → bug comes back. |
+| Race condition on shared state | Add a mutex → bug goes away under load. Remove mutex → bug comes back under load. |
+
+If you can't construct a toggle proof, you haven't confirmed the cause. Run one more round.
+
+### Update the journal
+
+```markdown
+## Root cause (confirmed <ISO timestamp>)
+- Mechanism: <one paragraph, causal not correlational — the chain from cause to observable symptom>
+- Evidence: <file:line of captured value | path to saved repro | address + register state>
+- Toggle proof: "With <change X>, repro produces <good>. Reverting <change X>, repro produces <bad>."
+- Fix scope: <files and approximate line count>
+```
+
+The "mechanism" field is the acid test. If you can't write the causal chain from cause to observable symptom as one paragraph, you don't yet understand the bug well enough to fix it.
+
+---
+
+## Phase 7 — TDD Fix
+
+Red, green, refactor. No shortcuts.
+
+### 1. Red — failing-first test
+
+Write a test that fails *specifically because of this bug*. Requirements:
+
+- **Test name reads like a bug report.** `test_refinement_turn_returns_empty_content_when_anthropic_returns_401` is good. `test_bug_fix` is not.
+- **Failure message clearly shows what the bug looks like.** If someone reads only the failure output, they understand what's broken.
+- **Minimum infrastructure.** Don't spin up the whole server if a unit test against the right seam captures the mechanism.
+
+Run the test. Confirm it fails. Paste the failure output into the journal:
+
+```markdown
+### Red phase (<ISO timestamp>)
+Test: <path>::<name>
+Command: <exact invocation>
+Output:
+```
+<verbatim failure output>
+```
+Confirms: the bug is reproducible at the test-harness level, not just the manual repro.
+```
+
+### 2. Green — minimum change
+
+Make the test pass with the **smallest change that fully fixes the observed mechanism**.
+
+If the diff is larger than ~30 lines and you aren't refactoring, something is wrong — either you're fixing more than the bug, or the root cause was deeper than you confirmed. Back to Phase 6.
+
+Signs you're over-fixing:
+- Adding "just in case" null checks or try/except around other code
+- Refactoring adjacent functions because "while I'm here"
+- Adding new configuration options the bug didn't require
+- Introducing new abstractions to "make this cleaner"
+
+Resist all of these. Fix the bug. Note the surrounding issues for follow-up. Move on.
+
+### 3. Refactor — ONLY AFTER GREEN
+
+Only cleanup directly related to the fix. Do not re-architect.
+
+If the code around the fix is rough, note it in the journal as a follow-up for the user; do not expand scope here. Refactoring during a bugfix is how one-line fixes turn into hundred-line diffs nobody can review.
+
+### 4. Regression — full suite green
+
+Run the full test suite for the affected package (not just the one new test). Existing tests must still pass.
+
+If they don't, your "fix" broke something else. Back to Phase 6 with the new failure as evidence — usually it means the mechanism you thought you fixed was load-bearing for some other code path you didn't know about, and the "broken" test is actually pointing at a better understanding of the system.
+
+### Update the journal
+
+```markdown
+### Green phase (<ISO timestamp>)
+Fix: <file:line> — <two-line description of the change>
+Test: <path>::<name> now passes
+Full suite: <N tests, <M failures — should be 0>
+```
+
+---
+
+## The red-green discipline summary
+
+No red test → no proof the fix addresses the reported bug. Only proof it doesn't break tests that already existed.
+
+A test written *after* the fix might still pass with the fix reverted. If that's the case, the test doesn't lock the bug — it locks something else. Always verify the test fails without the fix and passes with it. The journal should show both outputs.

package/packages/omo-codex/plugin/skills/debugging/references/methodology/08-qa.md

@@ -0,0 +1,94 @@
+# Phase 8 — Manual QA by Actually Using It
+
+Tests cover cases you thought of. Real usage covers the ones you didn't.
+
+The single fastest way to ship a broken fix is to stop at "tests pass". Manual QA means interacting with the running system the way the user does, then comparing observed behavior to the original bug report.
+
+---
+
+## Product-type playbook
+
+Pick the row that matches the product. Do what it says. Do not substitute.
+
+| Product type | QA means… |
+|---|---|
+| **CLI tool** | Open `tmux`, run the actual command end-to-end, capture output. Paste the session transcript into the journal. Include exit code, stdout, stderr, side-effect check (files created/modified). |
+| **HTTP API** | Start the real server, hit endpoints with `curl` or `httpie`, inspect response status + body + headers. Hit the specific endpoint that reproduced the bug. If there's auth, use real auth. |
+| **Browser-served web app** | **Drive a real browser via Playwright CLI.** See [tools/playwright-cli.md](../tools/playwright-cli.md). Navigate the exact page/flow that reproduced the bug. Capture screenshot + DOM + network evidence. **Do not substitute with curl** — browsers have state (cookies, localStorage, service workers, client-side JS, viewport-dependent CSS) that curl does not have. |
+| **Agent / LLM pipeline** | Run the same user prompt that originally failed. Capture the full turn — tool calls, messages, usage counters. **Confirm non-zero usage** (zero usage = still failing silently, see silent-failure check below). |
+| **Background worker / job queue** | Trigger the job through the normal entry point (API call, cron tick, message publish), tail the worker logs, observe completion state in the queue or DB. Don't just call the worker function directly — the trigger path matters. |
+| **MCP server** | Invoke the tool via its actual client (Claude Desktop, Cursor, etc. if available) or `mcp-cli`, not just the HTTP probe endpoint. The MCP handshake itself is sometimes where bugs live. |
+| **Native binary** | Re-run the exact command that crashed / misbehaved. If the input was a file, use the same file. If the bug was exploitable, confirm the exploit repro via pwntools (see [tools/pwntools.md](../tools/pwntools.md)). Capture exit code, signal if any, core dump if generated. |
+| **Bundled-app binary** (Bun SEA, Node SEA, Electron, etc.) | Re-run the exact command. If the operation requires paid quota / blocked network, capture the **app's debug log** (`APP_DEBUG=1 APP_LOG_LEVEL=debug APP_LOG_FILE=/tmp/trace.log`) which usually emits the assembled request before sending. See [methodology/partial-runtime-evidence.md](partial-runtime-evidence.md) for combining partial signals into a defensible verification. |
+| **Long-running daemon** | Start fresh, let it run for the amount of time the bug originally took to manifest (not less), capture resource usage (memory, fd, cpu) throughout. Short-running QA misses resource leaks and cumulative state bugs. |
+
+---
+
+## Journal format
+
+Every QA run goes in the journal under "Findings":
+
+```markdown
+### Manual QA — <product type> (<ISO timestamp>)
+- Scenario: <one line describing what you did>
+- Command: `<exact invocation>`
+- Observed output:
+```
+<verbatim output, trimmed to relevant section>
+```
+- Expected output: <what correct behavior looks like>
+- Fix verified: yes / no / partial — <details>
+```
+
+If any QA step shows **partial or regressed behavior**, this is not "mostly done" — it's incomplete. Return to Phase 6.
+
+---
+
+## The silent-failure check (always run)
+
+Regardless of product type, audit the fix against these silent-failure patterns. If the original bug was a silent failure, the same pattern may exist in adjacent code that you haven't tested yet.
+
+### Universal silent-failure signals
+
+- HTTP 2xx with empty or default body
+- Response `ok: true` but a sub-field contains an error token (e.g. `stopReason: "error"`, `status: "failed"`)
+- `usage.totalTokens === 0` on an LLM response
+- Process exit code 0 but stderr contains an exception traceback
+- Panic recovered and logged but ignored
+- Goroutine / task / promise rejection with no top-level handler
+- `try { ... } catch { /* swallowed */ }` or `except: pass`
+- Success response shape but semantic field indicates failure (e.g. `error: null` actually being `error: "..."` with falsy check)
+- Write returned success but read-back shows stale data
+- Job marked complete but side-effect did not happen
+- Cache hit path returned stale data and no refresh was triggered
+
+### Language-specific silent-failure signals
+
+Check the runtime reference for additional patterns:
+
+- [runtimes/python.md](../runtimes/python.md) — asyncio task exceptions, bare `except`, `logging.exception` that goes nowhere
+- [runtimes/node.md](../runtimes/node.md) — unhandled promise rejections, `void` on async, swallowed `.catch(() => {})`
+- [runtimes/rust.md](../runtimes/rust.md) — `.unwrap_or_default()`, `let _ = result`, error variants discarded
+- [runtimes/go.md](../runtimes/go.md) — `if err != nil { return err }` that never reaches user output, recovered panics, buffered channels that block silently
+- [runtimes/native-binary.md](../runtimes/native-binary.md) — ignored return codes from libc, missing `perror`, `alarm()` / signal masks
+- [runtimes/bundled-js-binary.md](../runtimes/bundled-js-binary.md) — `process.env.X` baked at build time, dead code from tree-shaking failures, worker sub-bundles diverging from main bundle
+
+### What to do when you find another silent-failure spot
+
+Don't fix it. This is out of scope for the current bug.
+
+Note it in the journal under a "Follow-ups" section with:
+- File:line
+- Pattern matched
+- Proposed fix sketch (one line)
+- Risk level (what happens if left unfixed)
+
+Surface these to the user in the final message under "Next steps I didn't take".
+
+---
+
+## The "fix verified" bar
+
+"Fix verified" means: the exact original failing scenario, re-run, now produces the correct output. Not a similar scenario. Not a unit test of the fix. The original scenario.
+
+If you can't re-run the original scenario (e.g. it required a specific data state that's gone), construct the closest equivalent and document the difference in the journal. Escalate to the user if the equivalent is materially different.