sessionreel 0.1.0__tar.gz

sessionreel-0.1.0/.claude-plugin/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "sessionreel",
+  "owner": { "name": "Youngmin Ko", "url": "https://github.com/mandu5" },
+  "plugins": [
+    {
+      "name": "sessionreel",
+      "source": "./",
+      "description": "Turn a Claude Code session into a short recap video. Local, redacted, no API key.",
+      "version": "0.1.0"
+    }
+  ]
+}

sessionreel-0.1.0/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "sessionreel",
+  "description": "Turn this Claude Code session into a 30-60 second recap video: the ask, the failing test, the fix, green, shipped. Rendered locally, secrets redacted, no API key. /reel writes the storyboard, rewrites the captions from what actually happened, and renders an mp4.",
+  "version": "0.1.0",
+  "author": { "name": "Youngmin Ko", "url": "https://github.com/mandu5" },
+  "homepage": "https://github.com/mandu5/sessionreel",
+  "repository": "https://github.com/mandu5/sessionreel",
+  "license": "MIT",
+  "keywords": ["video", "recap", "session", "demo", "share", "changelog", "ffmpeg"]
+}

sessionreel-0.1.0/.gitguardian.yaml

@@ -0,0 +1,6 @@
+# Redaction tests need strings shaped like credentials. They are fabricated
+# (e.g. "abcdefgh…", AWS's documented AKIAIOSFODNN7EXAMPLE) and assembled at runtime.
+version: 2
+secret:
+  ignored_paths:
+    - "tests/**"

sessionreel-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+.omc/
+.claude/
+__pycache__/
+*.pyc
+.venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+out/
+*.mp4
+!docs/*.mp4
+*.gif
+!docs/*.gif
+.DS_Store

sessionreel-0.1.0/DESIGN.md

@@ -0,0 +1,122 @@
+# sessionreel — design
+
+## Problem
+
+A coding agent can work for two hours and leave behind a 30 MB JSONL log. The work is real, but
+nobody else can see it: a teammate will not scrub a transcript, a client will not open a replay
+viewer, and a link on X is not a video. The existing tools (claude-devtools, claude-code-log,
+claude-replay, mindwalk, zoetrope) are *viewers* — the audience has to come to them and spend
+minutes. None of them produces the one artifact people actually share: a short video that plays
+inline and tells what happened.
+
+## Goal
+
+`sessionreel` turns one agent session into a 30–60 second video that is
+
+1. **true** — every frame is derived from the log (the real prompt, the real diff, the real
+   test output); nothing is invented, including by an LLM;
+2. **interesting** — it tells the story (goal → the failure → the fix → green → shipped), not a
+   random sample of 400 tool calls;
+3. **safe to post** — secrets, tokens, emails and home paths are redacted before anything is
+   drawn, and the report says what was removed;
+4. **free and local** — no API key, no upload, no Node/Chromium; one `uvx` command.
+
+Non-goals for v1: live capture, Codex/Cursor logs (adapter interface is in place; Codex is next),
+music, voices other than the OS voice.
+
+## Pipeline
+
+```
+session.jsonl ──ingest──▶ Session(events) ──redact──▶ Session' ──story──▶ Storyboard ──render──▶ mp4
+                                                                   ▲
+                                              optional: captions rewritten by the host agent
+```
+
+Every stage is a pure function with a JSON boundary, so `plan` and `render` can run separately
+and a user (or the agent in plugin mode) can edit `storyboard.json` in between.
+
+### ingest (`ingest/claude.py`)
+
+Claude Code writes one JSON object per line. We keep only the main thread
+(`isSidechain == false`) and normalise to five event kinds:
+
+| event | source |
+|---|---|
+| `Prompt(text)` | `type=user`, string content, not a command/caveat/system-reminder wrapper |
+| `Say(text)` | assistant `text` block |
+| `Tool(name, input, output, error, patch)` | assistant `tool_use` joined to the next `tool_result` by id; `patch` from `toolUseResult.structuredPatch` (Edit/Write/MultiEdit) |
+| `Usage(in, out, cache)` | assistant `message.usage` |
+| timestamps | every entry's `timestamp` |
+
+Malformed lines are skipped and counted, never fatal: logs are written live and may be truncated.
+
+### redact (`redact.py`)
+
+Runs on the normalised session, before the storyboard exists, so no later stage can leak.
+Patterns: provider keys (`sk-…`, `sk-ant-…`, `ghp_/gho_/github_pat_`, `AKIA…`, `xox[abpr]-`,
+`AIza…`), JWTs, `Bearer …`, `KEY=value` where KEY names a secret, URL credentials and token query
+params, e-mail addresses, and the user's home directory (→ `~`). Contents of `.env*`, `*.pem`,
+`id_rsa*` files are never shown. User-supplied `--redact REGEX` adds patterns. The count per
+category is printed and stored in the storyboard; `render` refuses a storyboard whose
+`redacted` flag is false.
+
+### story (`story.py`)
+
+Deterministic. Beats are detected, scored and packed into the time budget:
+
+- **goal** — the first substantive prompt (the ask).
+- **explore** — reads/greps/globs collapsed into one montage ("read 14 files").
+- **red** — a test/build command whose output shows failure (pytest/jest/go/cargo/tsc summary
+  lines, non-zero exit, `is_error`).
+- **fix** — the edits between a red and the next green of the *same* command family.
+- **green** — that command passing.
+- **ship** — `git commit`/`git push`/`gh pr create`/publish commands that succeeded.
+- **result** — the agent's final message, first sentence.
+- **stats** — duration, prompts, tool calls, files changed, lines ±, tests, tokens.
+
+The red→fix→green arc is the spine: if the session has one, the reel is built around the most
+recent complete arc. Otherwise the largest edits carry the middle. Captions are templated from the
+data ("3 tests failing", "fixed in `parser.py`", "12 passed"); they never claim what the log does
+not show.
+
+### captions
+
+Default: templates (offline, zero cost). Plugin mode: the agent that did the work rewrites the
+captions in `storyboard.json` — it has the context, and it runs inside the user's own session, so
+no extra API key or upload exists. The renderer does not care who wrote a caption; `plan` stores
+the template caption as `fact` next to it so a rewrite can be checked against the source.
+
+### render (`render/`)
+
+Pillow draws each frame; frames stream as raw RGB into ffmpeg (system binary, else the static
+binary from `imageio-ffmpeg`) → H.264 yuv420p, CRF 20, 30 fps. Formats: `square` 1080×1080
+(feeds), `wide` 1920×1080, `tall` 1080×1920. Scenes: title, prompt (typewriter), montage,
+terminal (typed command, output reveal, exit badge), diff (hunks, line-by-line reveal, syntax
+colour via Pygments), stats (counters), end card. Crossfades between scenes. Static layers are
+drawn once per scene and cached; per-frame work is only what moves. Optional `--voice` speaks
+each caption with the OS voice (`say` on macOS, `espeak-ng` on Linux) and stretches scenes to fit.
+
+Fonts are bundled (OFL): JetBrains Mono for code, Inter for UI, Pretendard for Hangul, with
+per-character fallback so a Korean prompt renders correctly.
+
+## Interfaces
+
+```
+sessionreel                      # latest session for the current directory → reel.mp4
+sessionreel list                 # recent sessions: id, when, project, prompts, tool calls
+sessionreel plan [SESSION] -o storyboard.json
+sessionreel render storyboard.json -o reel.mp4 [--format square|wide|tall] [--voice] [--gif]
+sessionreel demo                 # bundled sample session → demo.mp4 (no logs needed)
+```
+
+Claude Code plugin: `/reel` plans, lets the agent rewrite captions from its own context, renders,
+and prints the path.
+
+## Quality bar
+
+- Fixture sessions (synthetic, no personal data) covering: red→green arc, no tests, only
+  exploration, errors without recovery, Korean prompt, secrets in commands and outputs.
+- Unit tests per stage; a render smoke test that decodes the output with ffprobe (duration,
+  resolution, codec) and samples frames for non-blank content.
+- Redaction tests are adversarial: every pattern has a positive and a near-miss negative.
+- `ruff`, CI on macOS + Ubuntu, Python 3.10–3.13.

sessionreel-0.1.0/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 Youngmin Ko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+The fonts in src/sessionreel/fonts/ are distributed under the SIL Open Font License 1.1;
+see the OFL-*.txt files next to them.

sessionreel-0.1.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.5
+Name: sessionreel
+Version: 0.1.0
+Summary: Turn a Claude Code session log into a 30-60 second recap video. Local, redacted, no API key.
+Project-URL: Homepage, https://github.com/mandu5/sessionreel
+Project-URL: Issues, https://github.com/mandu5/sessionreel/issues
+Author: Youngmin Ko
+License-Expression: MIT
+License-File: LICENSE
+Keywords: claude-code,coding-agent,ffmpeg,recap,session,video
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Requires-Dist: imageio-ffmpeg>=0.5
+Requires-Dist: pillow>=10.0
+Requires-Dist: pygments>=2.15
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sessionreel
+
+**Your agent worked for two hours. Here is the 35-second version.**
+
+`sessionreel` reads a Claude Code session log and renders a short recap video: the ask, the
+test that went red, the diff that fixed it, the run that went green, what shipped. It runs
+locally, redacts secrets before anything is drawn, and needs no API key.
+
+<p align="center"><img src="docs/demo.gif" width="600" alt="sessionreel demo: 2 failed → 14 passed in 35 seconds"></p>
+
+```
+uvx sessionreel            # newest session in this directory → reel.mp4
+```
+
+[한국어](README.ko.md)
+
+## Why
+
+Agent sessions are real work that nobody else can see. A teammate will not scrub a 30 MB
+transcript, a client will not open a replay viewer, and a link on X is not a video. The tools
+that exist are viewers (you go to them); sessionreel makes the thing you send.
+
+What a reel is built from — all of it straight from the log:
+
+| scene | source in the log |
+|---|---|
+| the ask | the prompt that started this piece of work |
+| exploring | files read and searches run before the first change |
+| red | a test/build command whose output shows failures (`pytest`, `jest`/`vitest`, `go test`, `cargo test`, `tsc`, `ruff`, `mypy`, `make <target>`) |
+| the fix | the diffs Claude Code recorded between that red run and the next green run of the same check |
+| green | the same check passing |
+| shipped | a successful `git commit` / `git push` / `gh pr create` / publish, with the commit message |
+| numbers | active time (breaks over 15 min don't count), tool calls, files and lines changed, tests |
+
+No arc in the session? The reel is built from the largest edits instead. A long session with
+many unrelated tasks? The reel tells one episode — from the ask that led to the fix up to the
+next ask — so it doesn't end on another task's summary (`--whole` to override).
+
+## Install
+
+```
+uvx sessionreel                                          # run without installing
+pipx install sessionreel                                 # or install
+uvx --from git+https://github.com/mandu5/sessionreel sessionreel   # latest main
+```
+
+Python 3.10+. ffmpeg is used if it's on your PATH, otherwise the bundled static build from
+`imageio-ffmpeg`. Fonts are bundled (JetBrains Mono, Inter, Pretendard for Hangul, Noto Emoji).
+
+**As a Claude Code plugin** — the agent that did the work writes the captions:
+
+```
+/plugin marketplace add mandu5/sessionreel
+/plugin install sessionreel@sessionreel
+/reel
+```
+
+`/reel` plans the storyboard, rewrites the captions from its own context (only claims the
+scene data supports), and renders. Or `npx skills add mandu5/sessionreel`.
+
+## Use
+
+```
+sessionreel                          # this session inside Claude Code; else the newest one for this directory
+sessionreel 5e55a0d0                 # a session id prefix, or a path to a .jsonl
+sessionreel list                     # recent sessions: id, time, prompts, tool calls, project
+sessionreel demo                     # a bundled sample session — no logs needed
+
+sessionreel --format wide            # 1920×1080   (square 1080×1080 is the default; tall 1080×1920)
+sessionreel --lang ko                # Korean captions
+sessionreel --voice                  # narrate with the OS voice (say / espeak-ng), no cloud TTS
+sessionreel --gif                    # also write a GIF
+sessionreel --redact 'ACME-\d+'      # extra pattern to scrub (repeatable)
+sessionreel --project "client app"   # name shown on frames instead of the directory; --no-branch hides the branch
+```
+
+Edit before rendering:
+
+```
+sessionreel plan -o storyboard.json      # the story as JSON: scenes, captions, durations
+$EDITOR storyboard.json                  # rewrite captions, drop a scene, change timing
+sessionreel render storyboard.json -o reel.mp4
+```
+
+A 35-second 1080×1080 reel renders in about 30 seconds on an M1 Pro and is ~1 MB.
+
+## Privacy
+
+Redaction runs on the parsed session **before** the storyboard exists, so no later stage ever
+sees the original strings, and it runs **again at render time** over every string in the
+storyboard, so a caption edited by you or by an agent is checked too. It removes:
+
+- provider keys and tokens (Anthropic, OpenAI, Stripe, GitHub, GitLab, npm, PyPI, AWS, Slack,
+  SendGrid, Twilio, Google, Hugging Face), JWTs, bearer/basic auth, private-key blocks — also
+  when they span lines inside a diff — webhook URLs, credentials and tokens in URLs;
+- `SECRET=value`, `"api_key": "…"`, `--password …`, `mysql -p…`, `curl -u user:pass`;
+- long high-entropy strings that look like credentials;
+- your identity: home directory (→ `~`, including Claude Code's `-Users-you-…` form), username,
+  hostname, `user@host` prompts, e-mail addresses;
+- the contents of `.env*`, `*.pem`, `*.key`, `*.p12`, `*.tfvars`, `.git-credentials`,
+  kube/docker/AWS credential files — never shown at all.
+
+`plan` prints how many items were removed, by kind. `--project NAME` replaces the directory name
+shown on every frame and `--no-branch` hides the git branch. Captions whose numbers do not appear
+in the scene's data are flagged at render time.
+
+Redaction is pattern-based. **Watch the video before you post it.** Nothing is uploaded
+anywhere; sessionreel makes no network calls.
+
+## FAQ
+
+**Isn't this just a screen recording?** No recording happens. Every frame is drawn from the
+log: the real command, the real output, the real diff hunks Claude Code stored. You can make a
+reel of a session from last month.
+
+**Does an LLM write the story?** No. The planner is deterministic and every caption is built
+from numbers in the log. In plugin mode the agent may reword captions, but the skill forbids
+claims the scene data doesn't support, and each scene keeps its original `fact`.
+
+**Codex / Cursor / other agents?** Claude Code first. The ingest layer normalises to five event
+kinds, so another log format is one adapter; Codex is next. PRs welcome.
+
+**How is this different from claude-replay, mindwalk, zoetrope, claude-code-log?** Those are
+viewers — interactive pages or TUIs you open and explore. sessionreel produces a 30–60 second
+video that plays inline wherever you post it.
+
+## How it works
+
+`ingest` (JSONL → prompts, messages, tool calls joined to their results, diff hunks, token
+usage) → `redact` → `story` (finds the red→fix→green arc, scopes the episode, packs scenes into
+a time budget) → `render` (Pillow draws each frame; frames stream into ffmpeg as raw RGB →
+H.264). Design notes: [DESIGN.md](DESIGN.md).
+
+```
+python -m pytest -q      # 140 tests: ingest, adversarial redaction, check parsing, arcs, storyboard safety, rendering, CLI
+```
+
+## License
+
+MIT. Bundled fonts are under the SIL Open Font License 1.1 (see `src/sessionreel/fonts/`).

sessionreel-0.1.0/README.ko.md

@@ -0,0 +1,80 @@
+# sessionreel
+
+**에이전트는 두 시간 일했고, 보여줄 건 35초면 됩니다.**
+
+`sessionreel`은 Claude Code 세션 로그를 읽어 짧은 리캡 영상을 만듭니다. 요청이 무엇이었는지,
+어떤 테스트가 빨간불이 됐는지, 어떤 diff가 그걸 고쳤는지, 다시 초록불이 된 실행, 그리고 배포까지.
+모두 로컬에서 돌고, 그리기 전에 비밀값을 가리며, API 키가 필요 없습니다.
+
+<p align="center"><img src="docs/demo.gif" width="600" alt="sessionreel 데모: 2 failed → 14 passed, 35초"></p>
+
+```
+uvx sessionreel            # 이 디렉터리의 최신 세션 → reel.mp4
+uvx sessionreel --lang ko  # 한국어 자막
+```
+
+## 왜 만들었나
+
+에이전트 세션은 분명한 작업인데 다른 사람은 볼 방법이 없습니다. 동료는 30 MB 트랜스크립트를
+넘겨보지 않고, 고객은 리플레이 뷰어를 열지 않으며, X에 올린 링크는 영상이 아닙니다. 지금 있는
+도구들(claude-replay, mindwalk, zoetrope, claude-code-log)은 **뷰어**라서 사람이 찾아가야 합니다.
+sessionreel은 **보내는 물건**을 만듭니다.
+
+영상의 모든 장면은 로그에서 그대로 옵니다.
+
+| 장면 | 로그의 출처 |
+|---|---|
+| 요청 | 이 작업을 시작한 프롬프트 |
+| 탐색 | 첫 수정 전에 읽은 파일과 검색 |
+| 실패 | 실패가 찍힌 테스트/빌드 명령 (`pytest`, `jest`/`vitest`, `go test`, `cargo test`, `tsc`, `ruff`, `mypy`, `make <target>`) |
+| 수정 | 그 실패와 같은 검사의 다음 통과 사이에 Claude Code가 기록한 diff |
+| 통과 | 같은 검사의 성공 |
+| 배포 | 성공한 `git commit`/`git push`/`gh pr create`/publish와 커밋 메시지 |
+| 숫자 | 실제 작업 시간(15분 넘는 공백은 제외), 도구 호출, 바뀐 파일·줄, 테스트 |
+
+실패→수정→통과 흐름이 없으면 가장 큰 수정으로 영상을 만듭니다. 여러 작업이 섞인 긴 세션이면
+그중 **한 에피소드**(수정으로 이어진 요청부터 다음 요청 전까지)만 보여줘서, 다른 작업의 요약으로
+끝나지 않게 합니다. 전체를 원하면 `--whole`.
+
+## 설치
+
+```
+uvx sessionreel                   # 설치 없이 실행
+pipx install sessionreel          # 설치
+```
+
+Claude Code 플러그인으로 쓰면, 작업한 에이전트가 직접 자막을 씁니다:
+
+```
+/plugin marketplace add mandu5/sessionreel
+/plugin install sessionreel@sessionreel
+/reel
+```
+
+## 사용법
+
+```
+sessionreel list                     # 최근 세션 목록
+sessionreel 5e55a0d0                 # 세션 id 앞자리 또는 .jsonl 경로
+sessionreel demo                     # 내장 샘플 세션 (로그 없어도 됨)
+sessionreel --format tall            # 1080×1920 (쇼츠/릴스), wide = 1920×1080
+sessionreel --voice                  # OS 음성으로 내레이션 (say / espeak-ng, 클라우드 TTS 없음)
+sessionreel plan -o storyboard.json  # 스토리보드를 JSON으로 → 자막 수정 → sessionreel render storyboard.json
+```
+
+M1 Pro 기준 35초 1080×1080 영상 렌더링에 약 30초, 파일 크기 약 1 MB입니다.
+
+## 개인정보
+
+가리기(redaction)는 스토리보드가 만들어지기 **전에**, 파싱된 세션 전체에 적용됩니다. 이후 단계는
+원문을 볼 수 없습니다. Anthropic·OpenAI·GitHub·AWS·Slack·Google·Hugging Face 키, JWT, Bearer
+토큰, 개인 키, `SECRET=값` 형태의 할당, URL 속 자격증명·토큰, 이메일, 홈 디렉터리(→ `~`)를
+지우고, `.env*`, `*.pem`, `*.key`, `id_*` 같은 파일의 내용은 아예 보여주지 않습니다. 몇 개를
+지웠는지 종류별로 출력합니다.
+
+패턴 기반이라 완벽하지 않습니다. **올리기 전에 영상을 꼭 한 번 보세요.** 어디에도 업로드하지
+않고 네트워크 호출도 없습니다.
+
+## 라이선스
+
+MIT. 포함된 폰트는 SIL Open Font License 1.1 (`src/sessionreel/fonts/`).

sessionreel-0.1.0/README.md

@@ -0,0 +1,140 @@
+# sessionreel
+
+**Your agent worked for two hours. Here is the 35-second version.**
+
+`sessionreel` reads a Claude Code session log and renders a short recap video: the ask, the
+test that went red, the diff that fixed it, the run that went green, what shipped. It runs
+locally, redacts secrets before anything is drawn, and needs no API key.
+
+<p align="center"><img src="docs/demo.gif" width="600" alt="sessionreel demo: 2 failed → 14 passed in 35 seconds"></p>
+
+```
+uvx sessionreel            # newest session in this directory → reel.mp4
+```
+
+[한국어](README.ko.md)
+
+## Why
+
+Agent sessions are real work that nobody else can see. A teammate will not scrub a 30 MB
+transcript, a client will not open a replay viewer, and a link on X is not a video. The tools
+that exist are viewers (you go to them); sessionreel makes the thing you send.
+
+What a reel is built from — all of it straight from the log:
+
+| scene | source in the log |
+|---|---|
+| the ask | the prompt that started this piece of work |
+| exploring | files read and searches run before the first change |
+| red | a test/build command whose output shows failures (`pytest`, `jest`/`vitest`, `go test`, `cargo test`, `tsc`, `ruff`, `mypy`, `make <target>`) |
+| the fix | the diffs Claude Code recorded between that red run and the next green run of the same check |
+| green | the same check passing |
+| shipped | a successful `git commit` / `git push` / `gh pr create` / publish, with the commit message |
+| numbers | active time (breaks over 15 min don't count), tool calls, files and lines changed, tests |
+
+No arc in the session? The reel is built from the largest edits instead. A long session with
+many unrelated tasks? The reel tells one episode — from the ask that led to the fix up to the
+next ask — so it doesn't end on another task's summary (`--whole` to override).
+
+## Install
+
+```
+uvx sessionreel                                          # run without installing
+pipx install sessionreel                                 # or install
+uvx --from git+https://github.com/mandu5/sessionreel sessionreel   # latest main
+```
+
+Python 3.10+. ffmpeg is used if it's on your PATH, otherwise the bundled static build from
+`imageio-ffmpeg`. Fonts are bundled (JetBrains Mono, Inter, Pretendard for Hangul, Noto Emoji).
+
+**As a Claude Code plugin** — the agent that did the work writes the captions:
+
+```
+/plugin marketplace add mandu5/sessionreel
+/plugin install sessionreel@sessionreel
+/reel
+```
+
+`/reel` plans the storyboard, rewrites the captions from its own context (only claims the
+scene data supports), and renders. Or `npx skills add mandu5/sessionreel`.
+
+## Use
+
+```
+sessionreel                          # this session inside Claude Code; else the newest one for this directory
+sessionreel 5e55a0d0                 # a session id prefix, or a path to a .jsonl
+sessionreel list                     # recent sessions: id, time, prompts, tool calls, project
+sessionreel demo                     # a bundled sample session — no logs needed
+
+sessionreel --format wide            # 1920×1080   (square 1080×1080 is the default; tall 1080×1920)
+sessionreel --lang ko                # Korean captions
+sessionreel --voice                  # narrate with the OS voice (say / espeak-ng), no cloud TTS
+sessionreel --gif                    # also write a GIF
+sessionreel --redact 'ACME-\d+'      # extra pattern to scrub (repeatable)
+sessionreel --project "client app"   # name shown on frames instead of the directory; --no-branch hides the branch
+```
+
+Edit before rendering:
+
+```
+sessionreel plan -o storyboard.json      # the story as JSON: scenes, captions, durations
+$EDITOR storyboard.json                  # rewrite captions, drop a scene, change timing
+sessionreel render storyboard.json -o reel.mp4
+```
+
+A 35-second 1080×1080 reel renders in about 30 seconds on an M1 Pro and is ~1 MB.
+
+## Privacy
+
+Redaction runs on the parsed session **before** the storyboard exists, so no later stage ever
+sees the original strings, and it runs **again at render time** over every string in the
+storyboard, so a caption edited by you or by an agent is checked too. It removes:
+
+- provider keys and tokens (Anthropic, OpenAI, Stripe, GitHub, GitLab, npm, PyPI, AWS, Slack,
+  SendGrid, Twilio, Google, Hugging Face), JWTs, bearer/basic auth, private-key blocks — also
+  when they span lines inside a diff — webhook URLs, credentials and tokens in URLs;
+- `SECRET=value`, `"api_key": "…"`, `--password …`, `mysql -p…`, `curl -u user:pass`;
+- long high-entropy strings that look like credentials;
+- your identity: home directory (→ `~`, including Claude Code's `-Users-you-…` form), username,
+  hostname, `user@host` prompts, e-mail addresses;
+- the contents of `.env*`, `*.pem`, `*.key`, `*.p12`, `*.tfvars`, `.git-credentials`,
+  kube/docker/AWS credential files — never shown at all.
+
+`plan` prints how many items were removed, by kind. `--project NAME` replaces the directory name
+shown on every frame and `--no-branch` hides the git branch. Captions whose numbers do not appear
+in the scene's data are flagged at render time.
+
+Redaction is pattern-based. **Watch the video before you post it.** Nothing is uploaded
+anywhere; sessionreel makes no network calls.
+
+## FAQ
+
+**Isn't this just a screen recording?** No recording happens. Every frame is drawn from the
+log: the real command, the real output, the real diff hunks Claude Code stored. You can make a
+reel of a session from last month.
+
+**Does an LLM write the story?** No. The planner is deterministic and every caption is built
+from numbers in the log. In plugin mode the agent may reword captions, but the skill forbids
+claims the scene data doesn't support, and each scene keeps its original `fact`.
+
+**Codex / Cursor / other agents?** Claude Code first. The ingest layer normalises to five event
+kinds, so another log format is one adapter; Codex is next. PRs welcome.
+
+**How is this different from claude-replay, mindwalk, zoetrope, claude-code-log?** Those are
+viewers — interactive pages or TUIs you open and explore. sessionreel produces a 30–60 second
+video that plays inline wherever you post it.
+
+## How it works
+
+`ingest` (JSONL → prompts, messages, tool calls joined to their results, diff hunks, token
+usage) → `redact` → `story` (finds the red→fix→green arc, scopes the episode, packs scenes into
+a time budget) → `render` (Pillow draws each frame; frames stream into ffmpeg as raw RGB →
+H.264). Design notes: [DESIGN.md](DESIGN.md).
+
+```
+python -m pytest -q      # 140 tests: ingest, adversarial redaction, check parsing, arcs, storyboard safety, rendering, CLI
+```
+
+## License
+
+MIT. Bundled fonts are under the SIL Open Font License 1.1 (see `src/sessionreel/fonts/`).

sessionreel-0.1.0/commands/reel.md

@@ -0,0 +1,12 @@
+---
+description: Turn this session into a 30-60 second recap video (local, redacted, no API key)
+argument-hint: "[--lang en|ko] [--whole] [--project NAME] [--no-branch] [--format square|wide|tall] [--voice] [--gif]"
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+---
+
+Make a recap video of this session by following [`skills/sessionreel/SKILL.md`](../skills/sessionreel/SKILL.md). That file is the source of truth; do not reimplement its steps here.
+
+Arguments: `$ARGUMENTS` — pass `--lang`, `--whole`, `--project`, `--no-branch`, `--redact` to `plan`, and `--format`, `--voice`, `--gif` to `render`.

sessionreel-0.1.0/docs/launch/posts.md

@@ -0,0 +1,50 @@
+# Launch copy — sessionreel 0.1.0
+
+Rules learned from 2026 data (see the author's research notes): the video is the post; the
+number goes in line one; post where the audience already is; answer the three standard attacks
+("what's the use case", "it's a screen recording", "prove it") in the first reply.
+
+## X / Threads (English) — attach docs/demo.mp4 natively, not a link
+
+> My coding agent fixed a bug in 2 minutes. Showing someone took 20.
+>
+> So I built sessionreel: one command turns a Claude Code session log into a 35-second video —
+> the ask, the failing test, the diff, green, shipped. Local, secrets redacted, no API key.
+>
+> uvx sessionreel
+> github.com/mandu5/sessionreel
+
+Reply 1 (answer the attacks up front):
+> Not a screen recording — every frame is drawn from the log Claude Code already writes
+> (~/.claude/projects). You can make a reel of a session from last month. Nothing is uploaded;
+> redaction runs before anything is drawn. Watch it before you post it.
+
+## GeekNews (Show GN) — first-person, story first
+
+Title (site prepends "Show GN:"):
+> sessionreel – Claude Code 세션 로그를 35초 영상으로 만드는 도구
+
+Body:
+> 에이전트가 두 시간 동안 버그를 고쳤는데, 그걸 팀에 보여주려면 30 MB짜리 로그를 넘겨줄 수밖에
+> 없더라고요. 기존 도구(claude-replay, mindwalk 등)는 뷰어라서 상대가 직접 열어봐야 합니다.
+>
+> 그래서 로그를 읽어서 "요청 → 실패한 테스트 → 고친 diff → 통과 → 커밋"을 30~60초 영상으로
+> 만드는 CLI를 만들었습니다.
+>
+> - `uvx sessionreel` 한 줄. 로컬에서 Pillow로 그리고 ffmpeg로 인코딩, 네트워크 호출 없음
+> - 그리기 전에 API 키·토큰·이메일·홈 경로를 가리고, .env 같은 파일 내용은 아예 안 보여줌
+> - 실패→수정→통과 흐름을 로그에서 찾아서 스토리를 짬 (LLM이 지어내는 부분 없음)
+> - 긴 세션은 그중 한 에피소드만, 한국어 자막(`--lang ko`), 쇼츠용 세로(`--format tall`), OS 음성 내레이션
+> - Claude Code 플러그인으로 쓰면 작업한 에이전트가 자막을 직접 다듬음 (`/reel`)
+>
+> 로그만 있으면 한 달 전 세션도 영상으로 만들 수 있습니다. 올리기 전에 한 번은 꼭 보세요 —
+> 가리기는 패턴 기반입니다.
+
+## Hacker News — NOT from the author's account (karma 1, auto-flagged before)
+
+If someone else posts: title
+> sessionreel: turn a Claude Code session log into a 35-second video
+
+## r/ClaudeAI / r/ClaudeCode — video post
+
+> I made a CLI that turns a Claude Code session into a 35-second recap video (local, redacted)