Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@crates/cli/src/outline.rs`:
- Around line 1622-1632: The function extract_quoted uses the ? operator inside
the for loop which causes the whole function to return early instead of trying
other quote characters; update extract_quoted to handle the Option results
explicitly (use if let Some(start) = text.find(quote) { ... } else { continue }
and similarly for end on rest) so a missing start or end for one quote char just
continues the loop and only returns Some when a matching pair is found,
otherwise return None after the loop.

In `@docs/design/outline-command.md`:
- Around line 790-798: The example shows `sg outline crates` but the text
describes streaming JSON records; update the example to `sg outline crates
--json=stream` (or equivalent `--format=json --output=stream`) so the command
matches the claimed behavior, ensuring references to `sg outline crates` and the
`--json=stream` flag are used to locate and change the example; alternatively,
if you prefer text output, revise the bullets to describe plain text output
behavior instead of JSON streaming so the contract is unambiguous.

In `@scripts/outline_claude_benchmark.py`:
- Around line 1131-1158: The validator currently derives expected scenarios only
from runs.json and silently overwrites duplicate (scenario, arm, iteration)
entries; update validate_run_dir so it (1) checks that runs is a list and is
non-empty and adds an issue if empty, (2) before assigning into
by_key[(scenario, arm, iteration)] detect duplicates and append an issue (do not
silently overwrite), and (3) build the set of expected scenarios as the union of
scenarios found in runs and any scenario keys present in alignment (so missing
run records are caught); use the existing symbols runs, by_key, scenarios,
alignment and keep calls to validate_run_record/validate_raw_trace unchanged.
- Around line 1248-1252: parse_trace_tool_events currently only appends
tool_result content when it's a plain str, dropping structured contents like
lists of blocks; update the handling of item.get("content") in the branch for
item.get("type") == "tool_result" so that if result is a list/dict you extract
and append the textual parts (e.g., for list of blocks extract each
block["text"] when block.get("type") == "text", or recursively flatten strings),
otherwise convert non-string scalars to string and append; adjust code around
parse_trace_tool_events/tool_results to normalize all tool_result content into
strings so validate_raw_trace sees permission/argument text.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@crates/cli/src/outline/default_rule.rs`:
- Around line 510-516: The current Go extractor rule named "go-type" in
default_rule.rs always assigns kind: interface (deserializing to
SymbolType::Interface), causing type declarations like "type RouterGroup struct
{}" to be misclassified; split the rule into two distinct rules (e.g.,
"go-type-struct" and "go-type-interface") that match the AST forms for struct vs
interface and emit kind: struct for struct declarations and kind: interface for
interface declarations (so SymbolType::Struct is produced for structs), and
update the Go outline test in crates/cli/src/outline.rs to assert that
RouterGroup has symbol_type == Struct instead of Interface.

---

Outside diff comments:
In `@crates/cli/src/outline.rs`:
- Around line 448-450: The code currently swallows errors from extract_outline
and continues; instead propagate the first Err back to run_outline so the
command fails. Replace the let Ok(...) else { return WalkState::Continue; } with
code that does not ignore errors—either make the surrounding visitor/closure
return Result and call extract_outline(...) ? so errors bubble to run_outline,
or on Err(e) record the error and abort the walk (e.g., return WalkState::Quit)
and then return Err(e) from run_outline; reference extract_outline, run_outline
and avoid returning WalkState::Continue on Err.

---

Duplicate comments:
In `@crates/cli/src/outline.rs`:
- Around line 829-839: The function extract_quoted currently uses the `?`
operator inside the loop which returns from the whole function when a particular
quote char isn't found; update extract_quoted to try each quote style and only
skip that iteration if start or end is missing instead of returning early.
Replace uses of `text.find(quote)?` and `rest.find(quote)?` with explicit option
handling (e.g., if let Some(start) = text.find(quote) { ... } else { continue })
and similarly continue the loop when end is None or zero, keeping the existing
check that end > 0 before returning the matched substring.

---

Nitpick comments:
In `@crates/cli/src/outline.rs`:
- Around line 498-499: extract_outline currently calls outline_rules(lang,
catalog) and runs SerializableRuleCore::get_matcher for every file, causing
repeated matcher compilation; instead compile matchers once when the catalog is
loaded and reuse them per language. Modify the catalog-loading path to produce
and cache a Vec<RuleSpec> (or augment RuleSpec to include the compiled matcher)
keyed by SgLang (e.g., HashMap<SgLang, Vec<RuleSpec>>), store the cache in a
shared, thread-safe container (Arc/RwLock or similar), and update
extract_outline (and the other spots that call
outline_rules/SerializableRuleCore::get_matcher at the referenced sites) to
fetch the precompiled RuleSpec list from the cache rather than
rebuilding/compiling per file. Ensure the cache uses the same unique types:
SgLang, RuleSpec, SerializableRuleCore::get_matcher, and outline_rules.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Outside diff comments:
In `@benchmarks/outline_claude_benchmark.py`:
- Around line 1489-1509: The current concurrent scheduling submits all tasks at
once so a fatal run detected by report_run cannot stop already-submitted
futures; change to incremental scheduling: submit only up to args.jobs initial
futures from tasks, then in a loop use as_completed to get each finished future,
call future.result() and report_run(run); if report_run returns a fatal
exit_code, stop submitting new tasks, cancel any not-yet-started futures and
return that exit_code; otherwise append to indexed_runs and submit the next task
from tasks (using run_agent with the same args) to keep at most args.jobs in
flight. Update the logic around future_to_index, indexed_runs, run_agent, and
report_run to support popping the next task and cancelling outstanding futures
when a fatal error occurs.
- Around line 1177-1203: The validate_run_dir logic must not coerce untrusted
JSON directly; instead, check types and handle malformed fields by appending to
issues rather than raising. For metadata->options->repeats, ensure metadata and
its "options" is a dict and the "repeats" value is an int (or parse safely with
try/except) before assigning repeats; on parse failure append an issue. For each
raw_run in runs, verify raw_run is a dict (already done), then validate that
raw_run.get("scenario") and raw_run.get("arm") are strings and
raw_run.get("iteration") is an int-like value before casting; if any field is
missing or wrong type, append a descriptive issue (e.g., referencing the run or
index) and skip that run instead of using str(...) or int(...) coercion. Ensure
any JSON parsing/conversion errors are caught and added to issues so
--validate-run reports them instead of crashing.

In `@benchmarks/outline-benchmark.md`:
- Around line 296-312: The "The last completed full run is:" block currently
presents a specific run ID and model as if current; update that block to
explicitly mark it as a historical example by adding a timestamp and/or the
phrase "Example run (date: YYYY-MM-DD)" next to the run ID
(target/outline-agent-benchmark/4b9c98bc) and include the resolved model string
(claude-sonnet-4-6) in the same labeled sentence so readers know it's a
snapshot, e.g., annotate the run header and the offline validation command
(python3 benchmarks/outline_claude_benchmark.py --validate-run
target/outline-agent-benchmark/4b9c98bc) with the date or the word "example" to
avoid implying it is the current truth.