code-overview

## Project Context

- git installed: !`which git 2>/dev/null || echo "not installed"`
- gh installed: !`which gh 2>/dev/null || echo "not installed"`
- CLAUDE.md: !`find . -maxdepth 1 -name "CLAUDE.md" -type f`
- project-discovery.md: !`find . -maxdepth 3 -name "project-discovery.md" -type f`
- personal config directory: !`bash "${CLAUDE_PLUGIN_ROOT}/scripts/han-config-dir.sh" 2>/dev/null || echo "$HOME/.claude"`
- project .han/config.md: !`cat .han/config.md 2>/dev/null || echo ""`

As your first action, use the Read tool on `.han/config.md` inside the `personal config directory` path above. A read
that returns no file is no personal configuration: continue silently. When that file or the `project .han/config.md`
probe supplies content, apply it per [config-rule.md](../../references/config-rule.md), which governs precedence
between the two files, relative-path resolution, and what to do with a file that reads but cannot be used.

## Operating Principles

Read these before doing anything. They constrain every step below.

- **"Why" is the organizing question.** The overview exists to answer one question first: _why does this code exist?_ —
  and the answer is the real problem it solves or the goal it accomplishes for the business or a user, never the
  technical mechanics. Why it exists, why it works the way it does, why it is the current solution to a real need: that
  is the spine of the whole document. Everything else the overview carries — what it does, how it flows, where it
  connects, where to start — flows out of the why and exists to give the reader the context to understand it. "What",
  "how", "where", and "when" are not dropped or diminished; they are framed by and subordinated to the "why" they serve.
  BECAUSE a reader who knows what code does but not why it exists cannot make sound decisions about it — the why is the
  load-bearing understanding, and the rest is scaffolding around it. State the why as a solution to a need, and never
  invent a business rationale the evidence does not support; when the why can only be inferred, mark it as inferred.
- **The skill orchestrates and synthesizes; the agents discover, validate, then refine.** The skill resolves the target,
  classifies size, dispatches exploration, and writes the overview. `han-core:codebase-explorer` agents gather the
  surrounding code and context the synthesis draws on — they do not write the overview. After the draft is written,
  `han-core:adversarial-validator` re-reads the code to challenge the draft's claims for accuracy, and
  `han-communication:readability-editor` rewrites the corrected draft against the shared readability standard,
  preserving every fact; the skill applies the validator's corrections and the editor's rewrite. The skill itself
  produces the grouping, the charts, the orientation, and the final rewrite.
- **The overview applies the shared readability standard.** As it writes and refines the overview, the skill sources the
  standard by invoking `han-communication:readability-guidance` (Step 5) and applies it, holding the default audience
  frame: a capable reader who did not do this work and lacks the author's context. The standard governs how the overview
  reads (main point first, descriptive headings, one idea per paragraph, progressive disclosure), never whether a
  required fact about the code appears. Its dedicated `han-communication:readability-editor` pass (Step 7) replaces the
  older information-architect / junior-developer readability review; the accuracy validator is a separate pass and
  stays.
- **Diagram legibility is this skill's job, not the editor's.** The readability rewrite pass is barred from touching
  diagram bodies, so nothing but this skill checks whether a chart can be read. Apply the template's diagram rule as
  you draw each chart: boxes name components and boundaries, and fields, types, and technical annotations go into the
  prose beneath. BECAUSE the exemption is right for accuracy — an editor free to reword a box could silently change
  what the chart claims about the code — and the reading load it leaves behind has to land on someone.
- **Read-only, always.** The skill explains; it never edits the target. It writes only its own scratch overview file.
  BECAUSE the job is understanding, not modification — this keeps the skill safe to point at unfamiliar code.
- **Accurate to the code, always.** Every claim the overview makes — the why it states (grounded in commit and PR/issue
  intent, comments, and what the code visibly does toward a goal), what the code does, each flow step, each named entry
  point, each change grouped by intent — must be grounded in the actual code and its intent, never inferred past the
  evidence or invented. BECAUSE a confidently wrong overview is worse than none: it sends the reader to the wrong file
  with false confidence and silently corrupts the mental model the skill exists to build. The adversarial validation
  pass (Step 7) exists to catch this. It is accuracy control on the _description_, NOT a quality judgment about the code
  — the two are different lines, and crossing into the second is still forbidden.
- **No quality judgment, ever.** The overview raises no findings, severities, or recommended changes — including in the
  PR-mode "what to watch" section, which is navigational only. BECAUSE reviewing a PR's quality is `code-review`'s job;
  this skill only helps the reader understand the PR before they review it. Crossing this line collapses the boundary
  between the two skills. Saying the code does not support a change's stated reason is not a crossing: the claim under
  test there is the document's own leading claim about the reason, which this skill already owns and already validates,
  not a judgment about the code's quality.
- **No PR statistics, ever.** The overview never states lines changed, files changed, additions/deletions, commit
  counts, or any other diff-stat figure — not in the intro, not in a section