egregore-labs/egregore / .claude/skills/view
view
VerifiedGenerate a branded HTML artifact from Egregore data (quest, handoff, activity, board, network, or any document) and open it in the browser. Use for /view, 'render this', or 'show me visually'.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 21.8 KB |
| compose-scaffold.html | other | 17.7 KB |
SKILL.md
View on GitHub---
name: view
description: "Generate a branded HTML artifact from Egregore data (quest, handoff, activity, board, network, or any document) and open it in the browser. Use for /view, 'render this', or 'show me visually'."
---
Generate a branded HTML artifact from Egregore data and open it in the browser.
Works in both connected and local mode — resolves data from memory files, not the graph.
## When to invoke
User says: "show me visually", "render this", "view as artifact", "open in browser",
"make this readable", "generate artifact", "show me [quest/handoff/plan]", "/view"
Not this: terminal formatting → just format in markdown · dashboard → `/dashboard`
Arguments: $ARGUMENTS (Optional: artifact type and/or name, or a file path)
## Runtime source boundary
Resolve deictic requests from the current conversation before organizational
retrieval. When `this`, `that`, `it`, or `the above` unambiguously refers to
the single artifact just created, accepted, or shown, reuse its full content
already in context and stage it verbatim. If that content is collapsed or the
prior receipt supplies only a canonical path, open that exact path once through
`bin/search.sh open`; do not run `bin/search.sh query` to rediscover a known
artifact.
Resolve organizational sources from the attached authorized
`EGREGORE_ORG_CONTEXT_V1` block first. Do not repeat its retrieval or reopen
its already opened sources. When the requested source is absent, run one
Runtime query and open the selected canonical file through
`bin/search.sh open`; do not use raw `ls`, `find`, or graph traversal as an
authorization bypass. Local rendering is the default. Publishing or replacing
a stable hosted view requires an explicit `SHARE` request and checkpoint.
Never publish from an ordinary view request.
## Loom routing
Claude Code: use this Loom routing section. Other harnesses continue with
Rendering mode below.
Skip this section when the prompt contains `LOOM-EXECUTOR`; execute the
authorized render directly and never re-delegate.
Explicit `--compose`, designed/flagship, or client-facing requests remain
main-loop-only: render inline, then print
`bash bin/loom.sh footer view --override` and mark telemetry as an override.
For the deterministic renderer:
1. Resolve the route: run `bash bin/loom.sh route view` and read the JSON line it prints. When `bin/loom.sh` is not
present (Loom is internal-only and does not ship in the OSS distribution),
skip route resolution and the footer entirely and follow the script route
below — it is the framework default and needs no Loom.
2. **Script route (`"mode": "script"` — the framework default).** Judgment
stays in the main loop: resolve what the user means into a type and source
(the Resolution logic below). Then run the mechanics with no model in the
loop — one call, which stages the source through the Runtime read boundary,
serves repeat views from a content-addressed cache, renders, and opens:
`bash bin/view-render.sh <type> <memory/...-or-file> [-- --brief <path>]`.
Print its output verbatim, then `bash bin/loom.sh footer view`. Do not
spawn a subagent, re-open the source yourself, or re-run retrieval for the
render. If the script exits non-zero, report its error; only a composition
or interaction need justifies taking over inline.
3. For an inline route, continue below in the main loop.
4. For a delegate route (org override), delegate only when available and
permitted in this session; otherwise continue inline. When delegating,
spawn `loom-executor` at the returned tier with `LOOM-DECISION-ID`, `LOOM-EXECUTOR: Execute
.claude/skills/view/SKILL.md`, the user's exact arguments, and the attached
`EGREGORE_ORG_CONTEXT_V1` block verbatim; print its final output, then
`bash bin/loom.sh footer view`. On `LOW_CONFIDENCE:` take over inline.
5. Emit telemetry best-effort from the driver:
`bash bin/telemetry.sh emit "command" '{"command":"view","routed":true}' 2>/dev/null &`.
Loom transports the authorized context; it never grants new read or SHARE
authority. The minion workflow is unrelated to this render route.
## Rendering mode
Use the packaged deterministic renderer by default, driven through
`bin/view-render.sh` — rendering is mechanical, so no model belongs in that
path. Run inline composition only when the user explicitly requests it. A
normal “view/open/render this” uses the script route without duplicate
retrieval. A repeat view of unchanged content reports
`(served from render cache)` — that is expected, not staleness: the cache key
is the content bytes, the renderer, and the arguments.
## Supported artifact types
- `quest` — renders quest markdown from `memory/quests/`
- `handoff` — renders handoff markdown from `memory/handoffs/`
- `activity` — renders live team activity dashboard (no file needed)
- `board` — renders the typed live project-board surface (interactive editor with 5 tabs: Activity / Priority / Person / Timeline / Done). Publishing the stable hosted board is a separate explicit action.
- `network` — renders people/relationship network (no file needed)
- `document` — renders any markdown file with branded styling (auto-detected fallback)
## Resolution logic
The key job of `/view` is resolving what the user wants to see into a file path. This must work without a graph.
### 1. Parse the arguments
- `/view quest artifact-generation` → type=quest, name=artifact-generation
- `/view handoff oss-security-audit` → type=handoff, name=oss-security-audit
- `/view activity` → type=activity, no file needed
- `/view board` → type=board, typed live surface; no source path resolution
- `/view network` → type=network, no file needed
- `/view artifact-generation` → no type specified, search all types
- `/view memory/knowledge/decisions/some-decision.md` → direct file path
- `show me the security audit visually` → extract keywords, search
### 2. Resolve the file
**Direct canonical file path**: If the argument names `memory/...`, open it
through `bash bin/search.sh open "memory/..."` into a temporary render source.
A denied or missing source stops resolution; never pass the raw canonical path
to the renderer or fall through to an unchecked filesystem read. An explicit
non-memory path inside the current repository may be rendered as a repository
document, but it is never treated as organizational memory.
**Quest, handoff, document, or auto-detected name**: Prefer the best matching
canonical source and opened content already present in
`EGREGORE_ORG_CONTEXT_V1`; stage that content as a temporary render source
without reopening it. Otherwise run one ranked call, optionally including the
requested type in the concept, then open only the selected result into the
temporary render source:
```bash
bash bin/search.sh query "<artifact name and optional type>" -n 6 --compact --context-packet
bash bin/search.sh open "<selected memory/... path>"
```
Claude Code: `--compact --context-packet` keeps the ranked evidence out of the
visible transcript — the resolution query must never print result blocks
before the render. Pass the selected source to the renderer script as its
`memory/...` canonical path, never as an absolute filesystem path.
Infer the renderer type from the selected canonical path. If several results
are genuinely ambiguous, show the short choices rather than scanning the
repository again.
**Activity**: No file resolution needed — runs `bin/activity-data.sh` live.
**Board / Network**: Use only the renderer's typed Runtime-backed live surface;
do not pre-scan or pre-open memory files.
**Auto-detect type** (no type specified): infer `quest` or `handoff` from the
authorized result path; everything else is `document`.
### 3. Generate and open
**On the script route, `bin/view-render.sh` owns everything in this section**:
it resolves the packaged renderer locally (checked-out
`packages/egregore-artifacts` with dependencies first, then the instance's
managed renderer, then an installed `egregore-artifacts` on PATH;
never `npx`, never a registry fetch), stages complete `memory/...` documents
through the existing authorized `Runtime.open_source` adapter (ordinary model
evidence reads remain bounded), serves unchanged content from the content-addressed
render cache, invokes the renderer exactly once with `--output`, and opens the
browser. Call it once with the resolved type and source; do not re-implement
these steps inline. The commands below describe what the script does and are
the inline fallback only when the resolved route is `inline`.
**Design trace (documents).** A `document` render should follow the design
trace, not ship bare: auto-walk the UGI synthesis graph from the document's
substance (five stage ids — objective · audience · register · palette ·
grammar; option ids and auto-walk rules in
`packages/design-system/generative-ui/skill/SKILL.md`), resolve the brief, and
pass it to the renderer:
```bash
bash bin/node-run.sh --input-type=module -e "
import { resolveBrief } from './packages/design-system/generative-ui/resolve-brief.js';
import fs from 'node:fs';
fs.mkdirSync('tmp', { recursive: true });
fs.writeFileSync('tmp/view-brief-{slug}.json',
JSON.stringify(resolveBrief(['{objective}','{audience}','{register}','{palette}','{grammar}'])));
"
bash bin/view-render.sh document <memory/...-or-file> -- --brief tmp/view-brief-{slug}.json
```
Picking the five ids is judgment and stays in the main loop; the brief file
rides into the render through `--` and participates in the cache key.
Pick the five ids from the substance, one line of judgment each (e.g. a
strategy prep doc → decide · operators · editorial · ledger · decisive; a
public explainer → persuade · newcomer · marketing · ledger · quiet). For the
palette, use `ledger`, the registry default pair (`sovereign`), unless the
content has a stated reason for another registered pair; a palette with no
registered pair is never a default pick. The brief drives palette + grammar
treatment; the designed layout (nav · hero · anchored sections) renders
regardless. If the checked-out generative-ui layer is unavailable, render
without `--brief`; never fetch it or block on the trace.
The deterministic renderer already owns its light/dark theme contract. Do not
invoke or reread a separate visual-theme skill for an ordinary render. Apply
the Dark Mode contract only while authoring composed HTML or changing renderer
code.
### Composition path (`--compose`) — band 5, main-loop only
The template above is the **floor**. `--compose` is the **ceiling**: the design
trace at full depth means COMPOSITION, not pass-through (D6 free-generative band
— how the reference pages were made). The template renderer can never reach it;
composition is the frontier model authoring the page from the substance. This
path is what makes that reachable from the command instead of only by accident.
This path fires only on explicit cues: `--compose`, "compose / make it
presentable / client-facing / flagship / with the design trace / use the design
trace / designed artifact / band 5". **When the user names "the design trace,"
they mean this composed ceiling — never the floor.** Otherwise use the local
deterministic renderer.
**Technical documents compose too — in a different register.** A spec, RFC,
protocol, architecture doc, API reference, evaluation report, or postmortem is
flagship and gets the full chrome, but it does **not** get editorial voice. See
step 4 below: the register decision comes before any content is written, and
picking wrong is the single most common way a composed render lands badly.
**Procedure (run inline — never delegate; see the compose note in Loom routing):**
1. Read the source document in full. Then read what people have said they
like in generated interfaces and keep it as context: words to consider,
never a template to copy. `{task}` is a few words naming this work:
```bash
bash bin/genui.sh taste --task '{task}' --form view
```
2. Start from the scaffold: `.claude/skills/view/compose-scaffold.html` (copy it;
it carries the chrome — fonts, sticky nav, theme toggle, contours — and a
documented component kit). You fill content; you do **not** rebuild the
chrome or invent colors.
3. Walk the UGI graph for the register/palette/grammar (as above) and stamp the
manifest `register`/`grammar` + the footer trail. For the palette, use the
registry default pair (`sovereign`) unless the content has a stated reason
for another registered pair. The scaffold predates the registry: its theme
blocks are the `meridian` pair (`vellum`, `nocturne`) plus an older `loam`
block, and its header note to leave them in place no longer holds. Take the
chosen pair's two theme blocks from the first of these files that exists:
- `packages/design-system/dist/egregore-design.css` (the source repository)
- `packages/egregore-artifacts/lib/vendor/design-system/dist/egregore-design.css`
- `lib/vendor/design-system/dist/egregore-design.css` inside the installed
`egregore-artifacts` package that `bin/view-render.sh` runs
Replace all three scaffold blocks with them; match the `<html>` attributes,
the manifest `pair` and `resolvedTheme`, and the toggle's theme ids and
label to that pair; and point the scaffold's meridian-only names
(`--prussian*`, `--brass*`, `--teal`, `--rose`, `--contour`) at role tokens.
If none of the three files exists, keep the scaffold's `meridian` blocks and
say so in the report.
4. **Decide the register FIRST — editorial or technical.** This governs every
sentence you then write, and it is not a style preference; it is what the
document *is*. Ask: does a reader come here to be *persuaded of a view*, or
to *look something up and implement it*?
| | **Editorial** | **Technical** |
|---|---|---|
| Documents | strategy · prep · briefing · explainer · analysis · narrative recap · pitch | spec · RFC · protocol · architecture · API reference · evaluation report · runbook · postmortem |
| Headings | **statement titles** — the section's *finding* as display copy ("Most of the zoom-out is already decided.") | **descriptive, numbered** — the section's *name* ("3.3 Toponym and cultivar collision") |
| Hero | two-tone `Lead. <em>accent phrase</em>` + italic standfirst | plain title + a `.meta` grid (version · date · author · depends-on) |
| Prose | argues, lands a point, carries voice | states, qualifies, cites; declarative and neutral |
| Opens with | the claim | Abstract, then Scope |
| Decisions | `.hl` / `.readout` — the thing to land | explicit `Decision:` blocks, individually citable |
| Tables | `.sumtable`, status matrices | numbered with `<caption>` ("Table 2 — …") so prose can reference them |
| Never | bury the finding in a neutral heading | editorialize a heading, or assert without the measurement behind it |
Signals for technical: numbered sections, a version field, "spec"/"protocol"/
"requirements" in the title, code blocks carrying invocations, tables of
measurements, a References section. **When the document is something someone
will implement from, choose technical.** Editorial voice on a spec reads as
unserious and buries the lookup value — that is the failure mode this table
exists to prevent.
Stamp the choice into the manifest `register` and the footer trail
(`editorial` / `technical`, with a matching grammar such as `decisive` or
`specification`).
5. **Transform, don't mirror** — in the chosen register. Never reproduce the
markdown structure verbatim; pick a component per section from the kit by
what the content *is*:
- `.ledger` for Q→A pairs · `.tagcard` for named claims · `.claims` for
numbers/stats · `.panels`+`.verdict-band` for option sets · `.hl` for the
one thing to land · `.steps` for sequences · `.feat` for capability+status
rows · `.threads` for decision lists · `.gap` for negatives · `.sumtable`
with `.dot`s for a status matrix · `.readout` for the honest bottom line
- technical renders lean on captioned tables, `Decision:` blocks, numbered
rationale lists, and `.note`/`.note.caution` for limitations and hazards;
they use `.hl`/`.readout` sparingly and never as a substitute for a heading
- **Highlights: no side stripes.** Never draw a coloured bar down one side
of a box. In the scaffold, `.hl` is the quiet status panel (6% tone tint,
1px tone hairline, 12px radius) whose `.k` label carries the tone's shape:
● for the plain `.hl`, ▲ and ■ for its warn and critical variants.
`.readout` is the key point: bigger type, no box. Typed renders take the
same treatments from the kit's recipe classes
(`packages/egregore-artifacts/lib/recipe.js`): `.eg-mark` for a marker
under the words, `.eg-margin` with an `.eg-label` for a label in the
margin, `.eg-quote` for a quote with a hanging opening mark, and
`.eg-panel` with a shaped `.eg-label` for status
- **transformation in technical register means structure, not voice** — split
prose into tables, number the rationale, surface the decisions; do not
rewrite the author's claims into slogans
- nav links: one per composed section, to its `id` anchor
6. **Never inline a hex in content** — every theme-sensitive color is a
`var(--token)`, or the toggle breaks dark mode. The kit already obeys this.
Verify before opening: every `var(--x)` used must be defined in **both** of
the chosen pair's theme blocks (for `sovereign`: `[data-theme="ledger"]` and
`[data-theme="bedrock"]`), or dark mode breaks silently on that element.
7. Write to `/tmp/egregore-artifacts/composed-{slug}.html` and open directly
(`open <path>`), then report the path + `Renderer: composed (band 5, inline)`.
Composition is judgment, not a script — the scaffold is the vocabulary, the
substance decides the sentence. When `--compose` is absent, use the fast
template path below.
For typed artifacts with a file:
```bash
bash bin/view-render.sh <type> <memory/...-or-file>
```
For auto-detected (just a file path):
```bash
bash bin/view-render.sh document <memory/...-or-file>
```
For activity (no file — live surfaces are never cached):
```bash
bash bin/view-render.sh activity
```
**For an explicitly requested publish:** local render/open is already complete.
Authorize `SHARE` for the exact staged artifact and show a Publish / Cancel
checkpoint containing the organization, destination, title, source, and
whether a stable URL will be replaced. After approval, invoke the Runtime
publication adapter once. `/view` does not inspect hosting configuration or
manage publication transport itself. If no Runtime publication adapter is
available, keep the local artifact and say publishing is unavailable rather
than falling back to a legacy script. Notification consent remains separate.
### 4. Report
Report the exact HTML path returned by the renderer or written by composition;
do not infer a filename from the examples below.
```
✓ Artifact opened in browser
File: /tmp/egregore-artifacts/{type}-{name}-{ts}.html
```
Only after an approved SHARE action returns a URL, append:
```
◆ {receipt.url} (use the exact URL returned by the approved publication)
```
Read `org_slug` from `egregore.json`.
## Fallback
If the local renderer is unavailable, report that the instance renderer needs
installation or repair. Do not install or fetch software implicitly.
## Ambiguity handling
If the name matches multiple files, ask with a structured question when available and permitted in this session; otherwise ask in plain text:
```
Found multiple matches for "security":
1. handoffs/2026-03/31-cem-oss-security-audit.md
2. quests/oss-security-review.md
Which one?
```
If no matches found, **fall through to synthesis mode** (see below).
## Synthesis mode
When the input is a prompt or topic rather than a file name — or when file resolution finds nothing — synthesize an artifact from multiple sources.
1. **Reuse authorized evidence** — start from `EGREGORE_ORG_CONTEXT_V1`. If it
is absent or insufficient, run Runtime Observe once through
`bin/search.sh query`; open only a selected returned canonical source through
`bin/search.sh open`. Never scan `memory/`. Read repository files only when
the user explicitly asked to synthesize codebase material.
2. **Write a temporary markdown file** — synthesize only the authorized
evidence into `tmp/view-synthesized-{slug}.md`. When the
attached context already contains opened content, stage that content without
reopening its canonical source.
3. **Render it** — `bash bin/view-render.sh document tmp/view-synthesized-{slug}.md`
4. **Report** — same as normal: `✓ Artifact opened in browser`
This is the default fallback — don't ask the user if they want synthesis. If `/view auth architecture` doesn't match a file, just do the research and render it.
**When to synthesize vs. when to say "not found":**
- Prompt is a topic/question ("auth architecture", "how does onboarding work") → synthesize
- Prompt looks like a filename that should exist but doesn't ("my-missing-doc") → say not found
- Use judgment — if the user clearly expects a specific file, don't synthesize a guess
## Examples
```
> /view quest artifact-generation
✓ Artifact opened in browser
File: /tmp/egregore-artifacts/quest-artifact-generation.html
```
```
> show me the security audit visually
Resolving "security audit"...
Found: memory/handoffs/2026-03/31-cem-oss-security-audit.md
✓ Artifact opened in browser
File: /tmp/egregore-artifacts/handoff-31-cem-oss-security-audit.html
```
```
> /view memory/knowledge/decisions/auth-redirect.md
✓ Artifact opened in browser
File: /tmp/egregore-artifacts/document-auth-redirect.html
```
```
> /view activity
✓ Artifact opened in browser
File: /tmp/egregore-artifacts/activity-2026-04-06.html
```
```
> /view auth architecture
No file match — synthesizing from codebase...
Reading: api/main.py, api/auth.py, api/services/storage.py, ...
✓ Artifact opened in browser
File: /tmp/egregore-artifacts/document-auth-architecture.html
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |