pagewellCAUTION

From the repository's own README, as read at the audited commit. Badges and raw HTML are left out.

npx skills add pagewellai/pagewell -g

The instruction file, verbatim from the audited commit — this is the text the model reads, and the surface the audit's instruction layer examines. Quoted here so you can judge it without cloning anything.

---
name: pagewell
description: >
  Write and publish a document that looks designed — an article, a report, a
  one-pager, a handbook — or a one-page artifact that runs in the browser: a
  principle explainer, a playground. Hand back a link, a share code or one
  HTML file. Use for "write me an article", "make this a nice document",
  "explain how X works with a demo", "share or publish this", in any language
  ("写篇文章", "原理演示", "讲解页"); also for house templates, charts,
  managing published pages, and X Article drafts ("发到 X 长文").
metadata:
  version: "v0.7.1"
---

# PageWell

A template here is not a stylesheet. It is **a kind of page**: a skeleton, a
writing brief, the inputs you must collect before writing, the components it
gives you, and checks that tell you whether the draft is any good. Your job is
to take the one the request calls for, read what it hands you, and follow it.

**The request decides the template. Never offer a menu, never offer looks.**

| They asked for | Template |
|---|---|
| any document — an article, a post, a report, a guide, a one-pager | `article` (the only document template for now) |
| a page where the reader must see a mechanism work | `principle` (a running page, below) |
| a template by name (their own house template, say) | that one |

A résumé gets its own template later. Until then write it with `article` and
say in one line that it is laid out as an article.

Once the draft exists, **the template is fixed**: it is in the file's front
matter, `pagewell preview` shows exactly that, and you do not switch it or set
a `variant:`. Change it only if they explicitly ask for a different template.

## Classify first

**If JavaScript is off, is there still an article to read?**

| Yes | `doc` — Markdown, written with `article`. A demo inside it is an `embed`. |
| No, the page *is* the thing | `artifact` — one self-contained HTML file. Always sandboxed. |

Do not ask "is this a tool or an explainer". That is a template, not a kind.
Principle demos, playgrounds, converters, comparison boards are all artifacts.
A series of pages is several artifacts, or a `doc` tree — never one artifact
with a second HTML file.

Already have a finished HTML page (a Claude artifact, a generated report)?
Skip to `pagewell publish`. Still say it is an artifact, and read `render_mode`.

## The flow

Always begin with step 0. It is the automatic update check for both this skill
text and the CLI; do not wait for the user to ask whether an update exists.

```
0  pagewell doctor --json --skill-version v0.7.1
                                          not installed → scripts/install.sh
     unknown --skill-version → pagewell upgrade, then run step 0 again
     skill_update.available → run skill_update.command, then re-read SKILL.md
     update.required → pagewell upgrade; run the skill_update command it
       prints if any (npx skills update pagewell -g -y), then re-read SKILL.md
     update.available → same, one line to the user; do not stop for it
0b Classify: document or artifact (a running page)

── document ──
1  pagewell templates use article -o draft.md       (or the template they named)
2  COLLECT EVERY REQUIRED INPUT before writing a word
3  Write draft.md. Replace every ⟦...⟧.
4  pagewell check draft.md --json
     errors  → fix, re-run. Three rounds, then stop and ask.
     warnings→ read them out; they are opinions, not blockers
5  Read the rubric against your own draft
6  pagewell preview                    exactly what publishing will produce

── artifact ──
1  pagewell templates use principle -o page.html
2  COLLECT EVERY REQUIRED INPUT before writing a word
3  Write ONE html file. Replace every ⟦...⟧.
     No second page. No fetch. No form. State stays in memory.
4  pagewell check page.html --json     same three-round rule
5  Read the rubric. First frame must work with JS off (noscript).
6  pagewell preview                    the page itself, not an article shell

── then ──
7  Publish, or export one HTML file. Already have one? `pagewell publish <file>`
   Want it on X as well? `pagewell x draft draft.md` (§Sending to X)
8  Report: what you made, what you checked, what you had to make up
```

Steps 2, 4 and 5 are what separate a draft that lands from one that reads like
filler. Do not skip them because the piece seems short.

Writing, checking and exporting need **no account and no network**. Sign in only
when they want a link (§Publishing) — and then **walk them into it** rather than
failing: a free account is created by the same sign-in, see §Signing in.

## The tool kit is your instructions

`templates use` prints six things. Each is an instruction, not reference
material:

| | What to do with it |
|---|---|
| `inputs` | **Ask for every `required` one before writing.** This is the anti-invention rule |
| `brief` | Read it in full. The template author is talking to you |
| `structure` | Each section's `guide` is that section's requirement |
| `components` | The blocks you may use, each with a `syntax` you can copy verbatim |
| `checks` | What `pagewell check` will hold you to |
| `rubric` | Questions to ask yourself before handing over |

**What it will look like.** This skill carries each template's screenshots and
samples in `assets/templates/<id>/`: `desktop.webp` and `phone.webp` are the
template's preview page, `samples/*.md` are finished documents written with it.
The preview page itself is `template.preview_url` — for Article,
https://pagewell.ai/templates/article, rendered live from the first sample. If
they ask what it will look like before anything is written, give them that
link, or show `desktop.webp` if your interface can display an image — as a
picture of what is coming, not as a choice between looks. Before your first
document with a template, read one of its samples: it is the shape a finished
draft has.

⛔ **Do not invent facts to fill a required input.** No work history, no numbers,
no quotations, no client names. If the user says "just write something

CAUTIONgrade B · trust 89/100 Install with care. The audit found things worth knowing before you trust its output.

What the source does

Filesystem

none-observed

Network

declared (5 observation(s))

Shell

none-observed

Dependencies

pinned

Secrets in source

none-found

Findings (3)

| The output contains a `<form>` or a login box | **Refuse to publish.** The sandbox withholds `allow-forms`, and the platform forbids pages that collect credentials |

const lines = raw.replace(/^/, '').split('\n').map((line) => line.replace(/\r$/, ''))

curl -fsSL https://raw.githubusercontent.com/pagewellai/pagewell/main/scripts/install.sh | bash

Gates applied: no_behavioural_pass.