stakeholder-summary

## Project Context

- 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

- **Plain language only.** The stakeholder summary never contains file paths, line numbers, function or class names,
  library mechanics, database tables, API shapes, or language primitives. Use product-level subsystem names ("the
  telematics provider", "the customer list"), user-facing UI vocabulary (badge, popup, list), and behavioral verbs
  (create, edit, update, claim, merge, sync). A non-technical stakeholder must be able to read the document end-to-end
  without translation.
- **Center the customer, not the system.** Lead with the problem the customer experiences, then the capabilities
  introduced, then the experience, then the data flow, then what is out of scope, then the questions. The system is the
  means, not the subject.
- **High level only.** A stakeholder summary is for getting feedback before kickoff. Skip anything that would only
  matter once implementation has started: schemas, sequencing, file boundaries, test plans, rollout strategy, telemetry.
  If a detail is only meaningful to engineers, it does not belong in this document.
- **Diagrams carry weight.** Use Mermaid for both the user experience flow and the data flow before-and-after. Diagrams
  are not decoration — they replace paragraphs of prose, so they must be readable on their own.
- **Open questions are stakeholder-shaped.** The closing questions are framed in customer or product language, not
  engineering language. They ask stakeholders to confirm framing, scope, and trade-offs — not to make technical
  decisions.
- **Apply the shared readability standard.** As it writes and refines the summary, the skill sources the standard by
  invoking `han-communication:readability-guidance` and applies it, holding the named audience: the non-technical
  stakeholder. The plain-language rules above are this skill's domain-specific supplement to the shared standard, not a
  replacement for it. The standard's dedicated `han-communication:readability-editor` rewrite pass (Step 5) is this
  skill's readability rewrite; it and the standardized self-check (Step 6, Pass B) take the place of the freehand
  plain-language rewrite this skill used to run, so the summary gets one readability review, not two. The standard
  governs how the summary reads, never whether a required fact from the spec survives.

# Stakeholder Summary

## Step 1: Resolve the Source and Output Paths

Read the user's argument and conversation context. Identify:

1. **The source specification** — the file the summary will be derived from. Usually a `feature-specification.md`, but
   may be a PRD, design doc, or similar. If the user did not name a file, ask in one short message which file to
   summarize.
2. **The output path** — `stakeholder-summary.md` in the **same directory** as the source file. Do not place it anywhere
   else unless the user explicitly says so.
3. **Shaping context** — anything the user added about the audience, tone, or emphasis ("this is going to leadership",
   "lean into the customer-trust angle"). Capture it for use in Steps 3 and 4.

If `stakeholder-summary.md` already exists in the target directory, ask the user whether to overwrite, append a
timestamp suffix, or stop. Do not silently overwrite.

## Step 2: Read the Source and Project Context

Read the feature specification end-to-end. Then capture:

- The customer problem the feature addresses, in the customer's own words where possible.
- The capabilities the feature introduces, expressed as user-visible actions (not API endpoints, not database changes).
  This is true even if the outcome is an API and not user visible yet. We want to provide what the spec will do for our
  end users.
- The user experience: what the customer sees, what choices they make, what happens after each choice.
- The current data flow (what happens today) and the new data flow (what will happen after this ships), at the level of
  "system A sends X to system B".
- What the spec explicitly says is out of scope, deferred, or handled elsewhere.
- Any open questions the spec already names.

Read the CLAUDE.md in the project named in the specification and `project-discovery.md` if present — they may surface
vocabulary or naming conventions the stakeholder summary should follow.

## Step 3: Translate Technical Content into Plain Language

For every piece of content destined for the summary, apply a translation pass:

- **System names generalize one level up.** "PostgreSQL" → "the database"; "the FleetCommand API" → "the telematics
  provider"; "the React component" → "the screen".
- **API and data shapes become user-visible behaviors.** "POST /units/claim" → "Claim it"; "PATCH /customers/1/update
  endpoint with [field_name]" → "update the existing customer record".
- **Engineering trade-offs become product trade-offs.** "Eventually consistent reads from the replica" → not mentioned;
  "we are not building bulk actions" → "Bulk actions. One record at a time for now."
- **Acronyms and brand names** stay only if a stakeholder would already know them (e.g., the product's own brand,
  well-known integrations). Otherwise generalize.

If a piece of content cannot be translated without l