# readable-output

Adopt this skill: https://proskills.md/skills/other/sheygoodbai-readable-output-clawhub-readable-output-skill

Page: https://proskills.md/skills/other/sheygoodbai-readable-output-clawhub-readable-output-skill
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: clawhub/readable-output-skill/SKILL.md
size: 3817
upstream: https://github.com/sheygoodbai/readable-output/blob/main/clawhub/readable-output-skill/SKILL.md

```text
---
name: readable-output
version: 0.1.2
description: "Official 看得清 Readable Output skill. Turns dense AI replies into a clearer reading layer with overview, key points, warnings, next steps, and folded raw text."
license: MIT-0
tags: [readable-output, clawhub, openclaw, readability, ai-output, output-layout, multilingual-layout, local-first, "可读性", "排版", "多语言", "术语"]
source: Sheygoodbai/readable-output
trigger: "Readable Output"
metadata:
  openclaw:
    emoji: "🪟"
    homepage: "https://clawhub.ai/sheygoodbai/readable-output"
---

# Official 看得清 Readable Output Skill

Use this skill when the user wants to understand a long AI answer faster,
without changing the meaning, while still keeping the original wording nearby
for verification.

The goal is not decorative styling. The goal is faster understanding and safer
judgment.

This skill should do real work, not act like a directory card. It gives the
user an immediately cleaner version of the answer, while the plugin and browser
companion provide the more automatic experience.

## Activate this skill when the user asks for

- `把这个输出排版得更好读`
- `先说重点，再保留原文`
- `别用一大段术语压我`
- `像 tool output 一样整理`
- `做一个结论层`
- `分块显示`
- `显著提示风险`
- `换成更适合中文/英文/日文/韩文/阿拉伯文的排版`

## User value

- Understand the answer before being persuaded by it.
- See risk, uncertainty, and next steps before acting.
- Keep the raw wording folded underneath for a quick audit path.

## Core operating rules

1. Start with one short overview.
2. Group the main content into concise key points.
3. Pull warnings or uncertainty into a visually obvious note.
4. Add a short next-step section when action is implied.
5. Add one closing reminder when acting on the summary needs caution.
6. Keep code, logs, commands, or raw wording separate from the readability layer.
7. Adapt labels and chunking to the chosen output language.
8. Do not exaggerate with excessive highlighting.
9. If the answer is already clear, make only light edits instead of over-formatting.

## Language-aware defaults

- `English`: front-load the answer, then use explicit headings and short bullets.
- `Chinese`: shorter labels, shorter bullets, more paragraph breaks, less sentence stacking.
- `Japanese`: compact labels and aggressive chunking of dense text.
- `Korean`: clear headings and short bullet groups.
- `Arabic/Hebrew`: preserve RTL reading flow and isolate mixed-direction fragments when needed.

## Good first prompts

- `请把这段 AI 输出整理成更好读的版本，再保留原文折叠。`
- `Use a readability-first layout: overview, key points, warning, next step, reminder.`
- `把这段改成更适合中文阅读的排版。`
- `Reformat this for Arabic readability without changing the meaning.`

## Trust boundaries

- Do not claim hidden access to user local databases, private memory, or silent uploads.
- Do not imply guaranteed correctness, official endorsement, or staff-pick status.
- Keep the original wording available whenever the rewrite could affect user judgment.
- If code or command blocks matter, summarize them briefly and preserve the raw block separately.

## Canonical route

- ClawHub skill: discovery and quick manual use from search or homepage exposure.
- ClawHub plugin: main install path for automatic local readability layering.
- Browser companion: direct OpenClaw Web overlay path for users who need the web sidebar experience.

## Canonical links

- ClawHub skill page: `https://clawhub.ai/sheygoodbai/readable-output`
- ClawHub plugin page: `https://clawhub.ai/plugins/%40sheygoodbai%2Fopenclaw-readable-output`
- GitHub repository: `https://github.com/Sheygoodbai/readable-output`
```

## File: README.md
upstream: https://github.com/sheygoodbai/readable-output/blob/main/README.md

````text
# 看得清 Readable Output

看得清 Readable Output is an OpenClaw plugin plus ClawHub skill for one
specific job: make long AI output easier to scan and safer to act on.

It adds a local readability layer before the answer reaches the user:

- a short overview
- grouped key points
- warning callouts
- next-step cues
- a closing reminder
- the original output folded underneath

Canonical pages:

- Skill: `https://clawhub.ai/sheygoodbai/readable-output`
- Plugin: `https://clawhub.ai/plugins/%40sheygoodbai%2Fopenclaw-readable-output`

## Distribution model

This repo uses one product line with different entry points instead of several
separate brands:

- ClawHub skill: discovery surface and low-friction manual use
- ClawHub plugin: main install path for automatic local readability layering
- Chrome extension: honest direct overlay route for OpenClaw Web users
- Browser demo: proof path for users without local OpenClaw yet

The point is to keep naming, screenshots, and traffic focused on the same
canonical product rather than splitting users across several pages.

## Web-first demo

If you do not have local OpenClaw, start with the browser demo shipped in this repo:

- local demo entry: `docs/demo/index.html`
- GitHub Pages-ready root: `docs/index.html`

The demo runs entirely in the browser and reuses the same readability engine as
the plugin. It exists as a low-friction trial path, but the main install CTA
still stays on the ClawHub plugin page so traffic does not fragment.

## Browser overlay companion

For OpenClaw Web users who want the most direct interaction, this repo now also
ships a browser-side companion:

- extension folder:
  `browser-companion/openclaw-tool-overlay`
- local harness:
  `browser-companion/openclaw-tool-overlay/fixture.html`
- Chrome popup:
  `browser-companion/openclaw-tool-overlay/popup.html`
- Chrome options page:
  `browser-companion/openclaw-tool-overlay/options.html`

What it does:

- watches the real `Tool Output` sidebar in OpenClaw Web
- mounts an overlay inside the actual sidebar panel
- follows panel size changes and narrow-width states locally
- keeps a local on/off switch and raw-output foldback
- ships a real Chrome extension shell with popup, options page, badge, and shortcut

What it is not:

- not a ClawHub plugin listing
- not a host-UI patch inside the public OpenClaw plugin API
- not a remote service that uploads tool output somewhere else

## What it does

- restructures long AI replies into a tool-output-style readability layer
- ships a no-install web demo for users who want to test the behavior first
- increases white space and grouping through markdown sections
- isolates warnings and next actions so they are not buried in dense paragraphs
- adapts labels and chunking to the user's chosen language profile
- keeps the original reply available in a collapsed block
- works locally without uploading local chat content to any plugin database

## What it does not do

- It does not directly control OpenClaw's native font family, theme colors, or CSS line-height through the current public plugin API.
- It does not claim research-backed support for per-word font-size tricks such as enlarging roots or random emphasis bursts.
- It does not read local databases or ship hidden telemetry.

Current plugin-API reality:

- `skill` and `MCP` routes can change structure and wording.
- a plugin can automatically add the readability layer
- changing the host app's actual typography chrome still requires a UI patch
- directly covering the web `Tool Output` sidebar requires a browser-side companion or a Control UI patch

Marketplace reality:

- the skill can serve as a discovery page on ClawHub
- the plugin should remain the primary automatic-install CTA
- web-overlay claims should stay attached to the Chrome extension path, not the plugin listing

Web-first reality:

- without local OpenClaw, the web demo is the closest honest substitute
- it cannot intercept host-side output automatically
- it can still prove whether the readability layer is useful before install

## Why this approach is evidence-aligned

This plugin follows stable readability guidance rather than aesthetic guesswork:

- W3C WCAG visual-presentation guidance favors restrained line width, non-justified text, and usable spacing.
- W3C text-spacing guidance shows users need line-height and paragraph spacing headroom.
- W3C contrast guidance supports high enough contrast for readable text.
- W3C international layout guidance shows script direction, line breaking, and punctuation handling differ across Arabic, Chinese, Japanese, Korean, and Latin-script text.

Public source entry points:

- `https://www.w3.org/WAI/WCAG21/Understanding/visual-presentation`
- `https://www.w3.org/WAI/WCAG21/Understanding/text-spacing`
- `https://www.w3.org/WAI/WCAG21/Understanding/contrast-minimum`
- `https://www.w3.org/TR/clreq/`
- `https://www.w3.org/TR/alreq/`
- `https://www.w3.org/TR/jlreq/`

## Install

```bash
openclaw plugins install clawhub:@sheygoodbai/openclaw-readable-output
openclaw plugins enable readable-output
```

Then turn it on:

```text
/readable on
```

If the plugin does not appear immediately in `openclaw plugins list`, restart
the gateway once after install or enable.

Standalone skill route:

```bash
clawhub install readable-output
openclaw skills install readable-output
```

No local OpenClaw yet:

- open `docs/demo/index.html` directly in a browser
- or publish the `docs/` folder with GitHub Pages

For OpenClaw Web users:

- load the unpacked browser companion from
  `browser-companion/openclaw-tool-overlay`
- it targets the web `Tool Output` sidebar directly

## Commands

- `/readable on`
- `/readable off`
- `/readable adaptive`
- `/readable always`
- `/readable auto`
- `/readable en`
- `/readable zh`
- `/readable ja`
- `/readable ko`
- `/readable ar`
- `/readable he`
- `/readable compact`
- `/readable balanced`
- `/readable spacious`
- `/readable status`
- `/readable help`

## Language profiles

- `auto`: detect from the active conversation
- `en`: Latin-script defaults with explicit headings and concise bullets
- `zh`: shorter section labels, denser chunk splitting, less sentence stacking
- `ja`: short labels, compact bullets, and aggressive paragraph splitting
- `ko`: clear headings, shorter bullets, and compact grouping
- `ar`: RTL-friendly labels and stronger separation of code, links, and numbers
- `he`: RTL-friendly labels and stronger separation of mixed-direction content

## Example

Input:

```text
This probably works, but there are a few caveats worth calling out. From a practical standpoint the main bottleneck is dependency drift, and before we say it is done we should verify the output file, rerun the test, and check whether the config change actually shipped.
```

Readable layer:

```md
## Overview
Before calling this done, verify the file, rerun the test, and confirm the config really shipped.

## Key points
- The current answer is mostly about caveats and verification.
- Dependency drift is the main bottleneck mentioned here.
- The safe path is to check proof, not just trust the summary.

> **Watch for:** The reply implies completion confidence before proof is shown.

## Next step
- Verify the output file.
- Rerun the test.
- Confirm the config change really shipped.

> **Reminder:** If the decision matters, expand the original wording before you act on the summary.

<details>
<summary>Original output</summary>

This probably works, but there are a few caveats worth calling out...

</details>
```

## Demo sync

The plugin and demo share one engine source:

- shared engine: `shared/readable-engine.js`
- plugin re-export: `src/readable-core.js`
- demo copy target: `docs/demo/readable-engine.js`

After editing the shared engine, sync the demo copy:

```bash
npm run sync:demo-core
```

Sync the browser companion bundle:

```bash
npm run sync:browser-core
```

Generate icons and package the Chrome extension:

```bash
npm run generate:browser-icons
n
````
