# codeck

Adopt this skill: https://proskills.md/skills/other/hiyeshu-codeck-skills-codeck

Page: https://proskills.md/skills/other/hiyeshu-codeck-skills-codeck
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: skills/codeck/SKILL.md
size: 8030
upstream: https://github.com/hiyeshu/codeck/blob/main/skills/codeck/SKILL.md

````text
---
name: codeck
version: 2.4.1
description: |
  codeck entry point. Scans local files for materials, shows pipeline
  dashboard with diagnostic intelligence, guides user to the next step.
  Use when the user says "codeck", "new deck", "make a presentation",
  "make a deck", "new slides", "build a presentation", "export",
  "speech", "script", or wants to start or continue a presentation
  project. /codeck is the user-facing entry; legacy sub-skills are
  internal modules.
---

<!--
[INPUT]: Depends on local project materials and $DECK_DIR room artifacts.
[OUTPUT]: Provides the /codeck entry protocol, routing rules, and Decision Ask semantics.
[POS]: skills/codeck entry lane; orchestrates fixed lanes and owns room state rules.
[PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
-->

# codeck — Deck Room Entry

Open the deck room, scan materials, diagnose project state, route work to role lanes, and write the role channel as work moves.

Flag anomalies proactively: stale stages, upstream changes not reflected downstream, unresolved threads, and tasks without a handoff.

## Deck room model

codeck follows a slock-style collaboration model in one skill runtime.

A skill is a channel: an addressable role with a clear write boundary, durable
room files, and a handoff protocol. `/codeck` is the entry channel. The
sub-skills are internal channels that own one part of the room.

Fixed role lanes:

| Handle | Owns | Writes |
|--------|------|--------|
| `@orchestrator` | room state, routing, task tickets, threads, handoffs | `MEMORY.md`, `tasks/tasks.md`, `threads/threads.md`, `channel/YYYY-MM-DD.md`, `roles/*.md` |
| `@outline` | narrative, deck content, slide structure | `deck.md` |
| `@design` | design skeleton, visual system, HTML source | `DESIGN.md`, `custom.css`, `slides.html` |
| `@review` | audience resistance, QA, scoped fixes | `review.md`, scoped fixes to `slides.html` / `custom.css` |
| `@speech` | talk track, presenter notes | `speech.md`, HTML `data-notes` |
| `@export` | PDF/PPTX output and export QA | PDF/PPTX files, export notes in `review.md` or `MEMORY.md` |

Dynamic role persona:

- Read `diagnosis.md` for the recommended person behind `@outline`, `@design`, and `@review`.
- The fixed handle owns the work. The dynamic person shapes the judgment.
- Example: `@outline` may work with Feynman's instinct; `@design` may use Ravel's formal logic.

Default user-facing output is compact: judgment, artifact, next action. The expanded role channel is written to `channel/YYYY-MM-DD.md`; show it only when the user asks to see the channel.

Compact response shape:

```markdown
codeck: {state}

I read this as {task}. I {did/will do} {action}.

Artifact: `{path}`
Next: `{next command or next lane}`
```

When the user asks to see the channel, show the handoff:

```markdown
@orchestrator
I read the current request as: {task}. Owner: @outline.

@outline
I will change `deck.md` first and leave visual files alone.

@design
I will rebuild `slides.html` and `custom.css` after the content changes.

@review
I will check whether the change lands for the target audience.
```

## Room document contract

Room documents are not equal. The room has one current truth layer, one work-state layer, and one audit layer.

| Layer | Files | Read rule | Write rule |
|-------|-------|-----------|------------|
| Current truth | `MEMORY.md`, `deck.md`, `DESIGN.md`, `custom.css`, `slides.html`, latest assembled HTML, `speech.md` when present | Read first. These files define the rebuildable deck. | Rewrite compactly so they describe the current room, not the whole history. |
| Work state | `diagnosis.md`, `tasks/tasks.md`, `threads/threads.md`, `roles/*.md`, `review.md` | Read current material diagnosis, active tickets, open decisions, lane persona/rules, and the latest valid review. | Keep live coordination clear; mark old decisions answered/defaulted/superseded. |
| Audit trail | `channel/YYYY-MM-DD.md`, legacy `PROJECT.md`, legacy `outline.md`, legacy `design-notes.md`, superseded review notes, generated old previews | Read only when debugging history or when the user asks to see the channel. | Append-only or leave untouched. Never use as generation truth. |

Read order for every lane:

1. `MEMORY.md` Active Context, Role Registry, Open Threads, Task Index, Artifacts, Assumed Defaults, Decision Log.
2. `tasks/tasks.md` open or active rows only.
3. `threads/threads.md` open rows and their detail blocks only; closed rows are audit evidence.
4. `diagnosis.md` for material interpretation and dynamic persona, when present.
5. `roles/{lane}.md` for current lane persona and lane-local rules.
6. Owned source: `deck.md`; `DESIGN.md` before `custom.css` / `slides.html`; assembled HTML only after `build-html.sh`.
7. `channel/YYYY-MM-DD.md` only for audit/debug. Channel text must not override current truth.

Legacy artifacts:

- `outline.md` is audit-only if found from an older room. Do not read, write, or recreate it during normal generation.
- `design-notes.md` is a legacy design scratchpad from main. Do not recreate it; migrate useful facts into `DESIGN.md`, `roles/design.md`, or latest valid `review.md`.
- `review.md` is the latest QA report only when it matches the current assembled HTML. If HTML changed after review, treat review as stale.
- Old project-root `*-rN.html` or `*-deck.css` files are historical unless they were produced by the current `build-html.sh` path.

## Memory protocol

`MEMORY.md` is the deck room index and current-state map. It replaces `PROJECT.md`.

Keep it short. Store current decisions, state, and indexes. Do not paste the full deck, channel transcript, or stale preview history.

`MEMORY.md` must include:

```markdown
# Memory

## Active Context
- Current request:
- Active lane:
- Next:
- Blockers:

## Room Truth Contract
- Current truth: MEMORY.md, deck.md, DESIGN.md, custom.css, slides.html, latest assembled HTML, speech.md when present.
- Work state: diagnosis.md current material reading, tasks/tasks.md active tickets, threads/threads.md open decisions and decision ledger, roles/*.md lane memory, latest valid review.md.
- Audit only: channel/YYYY-MM-DD.md, legacy PROJECT.md, legacy outline.md, legacy design-notes.md, superseded reviews, old previews, project-root sibling CSS.
- Rule: audit text never overrides current truth; legacy outline.md is never a generation source.

## Role Registry
| Handle | Dynamic persona | Owns | Writes |
|--------|-----------------|------|--------|
| @orchestrator | codeck room lead | room state, routing, handoffs | MEMORY.md, tasks, threads, channel, roles |
| @outline | {from diagnosis.md or fallback} | narrative and deck content | deck.md |
| @design | {from diagnosis.md or fallback} | design skeleton, visual system, HTML source | DESIGN.md, custom.css, slides.html |
| @review | {from diagnosis.md or fallback} | audience resistance and QA | review.md, scoped source fixes |
| @speech | {coach if needed} | speech script and presenter notes | speech.md, HTML data-notes |
| @export | publisher | PDF/PPTX output and QA | PDF/PPTX, export notes |

## Latest Channel Summary
{short summary of the latest role exchange}

## Open Threads
| ID | Kind | Owner | Status | Blocking | Writes To | Decision |
|----|------|-------|--------|----------|-----------|----------|

## Task Index
| Task | Owner | Status | Artifact | Handoff |
|------|-------|--------|----------|---------|

## Artifacts
- Diagnosis:
- Content source:
- Design source:
- Current preview:
- Latest review:
- Speech:
- Final exports:

## Assumed Defaults
- {field}: {value} — {reason}

## Decision Log
| Time | ID | Moment | Resolution | Source |
|------|----|--------|------------|--------|
```

Workspace directories:

```text
$DECK_DIR/MEMORY.md
$DECK_DIR/channel/YYYY-MM-DD.md
$DECK_DIR/tasks/tasks.md
$DECK_DIR/threads/threads.md
$DECK_DIR/roles/orchestrator.md
$DECK_DIR/roles/outline.md
$DECK_DIR/roles/design.md
$DECK_DIR/roles/review.md
$DECK_DIR/roles/speech.md
$DECK_DIR/roles/export.md
````

## File: README.md
upstream: https://github.com/hiyeshu/codeck/blob/main/README.md

````text
<div align="center">

# codeck

**A skill is a channel. codeck is a deck room.**

[Live demo →](https://codeck.sh/codeck-intro)

English | [简体中文](README.zh.md) | [繁體中文](README.zh-TW.md) | [日本語](README.ja.md) | [한국어](README.ko.md)

</div>

You have a folder of notes, docs, data, and images. You want a presentation. You type `/codeck`.

codeck opens a persistent deck room. Each codeck skill enters that room as a channel: outline, design, review, speech, and export.

A channel has an address, a write boundary, room files, and a handoff. The room keeps the current deck state in `~/.codeck/projects/{slug}/`, so work can continue across runs without relying on chat memory.

The result is a single HTML file. No templates. No slide-type vocabulary. Free HTML per slide — the AI can invent any visual form your content needs.

## How it works

`/codeck` opens the room and reads the project. The outline channel shapes the story. The design channel gives the story visual form. The review channel pushes back like the hardest audience member. Speech and export channels prepare delivery.

The handoff lives in the room, not in chat history.

## Three ideas

**A skill is a channel.** codeck is not a single long prompt pretending to be a team. Each skill owns one channel in the room: what it listens for, what it writes, and who it hands off to.

**Isomorphic mapping.** Before designing, codeck analyzes the *formal structure* of your content — its tension curve, information density, emotional arc. Then it finds a structural match from another domain: a piece of music, a painting style, an architectural principle. Your slides don't just *contain* your argument — they *look like* it. (Inspired by Hofstadter's *GEB*.)

**No schema ceiling.** Most slide tools give you a vocabulary of block types — title, bullets, image, quote. codeck gives the AI free HTML. If your content needs a visual form that doesn't have a name yet, the AI can invent it.

## Install

### Claude Code (recommended)

```
/plugin marketplace add hiyeshu/codeck
/plugin install codeck@codeck
```

Type `/codeck` to start (shown as `/codeck:codeck` in the plugin namespace).

### Codex

```bash
codex plugin marketplace add hiyeshu/codeck --ref main
codex plugin add codeck@codeck-github
```

Start a new task so the skills load, then type `/codeck`.

### Other agents

Works with [Cursor](https://cursor.com) and [40+ other agents](https://skills.sh).

```bash
npx skills add hiyeshu/codeck
```

## Local development — clone and edit live

The repository is its own marketplace: the plugin's source points at the repo root, so a local clone is a live, editable install.

```bash
git clone https://github.com/hiyeshu/codeck && cd codeck
```

- **Claude Code, in place (immediately live):** `claude --plugin-dir .` — edits to any SKILL.md, engine.css, or reference file are picked up with `/reload-plugins`.
- **Claude Code, marketplace path:** `/plugin marketplace add /path/to/codeck` then `/plugin install codeck@codeck`. This copies into the plugin cache; after edits run `/plugin marketplace update codeck` and reinstall to refresh.
- **Codex:** `codex plugin marketplace add /path/to/codeck`, then `codex plugin add codeck@codeck-github`; refresh after edits with `codex plugin marketplace upgrade codeck-github`.
- **Universal escape hatch (any runtime, always live):** point the skills at your clone — every Setup block honors these before any probe.

  ```bash
  export CODECK_SKILL_DIR=/path/to/codeck/skills/codeck
  export CODECK_DESIGN_DIR=/path/to/codeck/skills/codeck-design
  export CODECK_EXPORT_DIR=/path/to/codeck/skills/codeck-export
  ```

## The HTML file

The output is a self-contained HTML file. Open it in any browser. No server, no build tools.

### Keyboard shortcuts

| Key | Action |
|-----|--------|
| `→` `↓` `Space` `Enter` | Next step (fragment or slide) |
| `←` `↑` `Backspace` | Previous step |
| `Esc` | Toggle overview grid |
| `F` | Toggle fullscreen |
| `P` | Open presenter mode |

Touch: swipe left/right to navigate. A floating toolbar appears at the bottom on hover (desktop) or always visible (mobile).

### Presenter mode

Press `P` to open a presenter window with:

- **Current slide** — large preview at your current fragment step
- **Next preview** — shows what comes next (next fragment or next slide)
- **Speaker notes** — scrollable, with zoom controls (`+` / `-`)
- **Timer** — auto-starts on first navigation, click to pause, double-click to reset
- **Theme toggle** — switches light/dark for all UI chrome (toolbar, overview, presenter panel)

The presenter window syncs with the main window via BroadcastChannel. Navigate from either side.

### Overview mode

Press `Esc` to see all slides as a grid. Click any thumbnail to jump. Works in both slide view and presenter mode.

## Acknowledgments

The slide engine's navigation UI is inspired by [Slidev](https://github.com/slidevjs/slidev).

## License

MIT
````
