log-conversation
Record the current Claude Code conversation as a markdown file under $HOME/cclogs/{slug}/ for later reuse (memos, blog drafts, esa). Use when: (1) User says 'log conversation', 'record conversation', 'log-conversation', 'start logging', 'stop logging', (2) User invokes /log-conversation directly with args like -a, --all, -e, --end, or a number, (3) User wants to snapshot the chat to articlify or quote later.
Best use case
log-conversation is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Record the current Claude Code conversation as a markdown file under $HOME/cclogs/{slug}/ for later reuse (memos, blog drafts, esa). Use when: (1) User says 'log conversation', 'record conversation', 'log-conversation', 'start logging', 'stop logging', (2) User invokes /log-conversation directly with args like -a, --all, -e, --end, or a number, (3) User wants to snapshot the chat to articlify or quote later.
Teams using log-conversation should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/log-conversation/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How log-conversation Compares
| Feature / Agent | log-conversation | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Record the current Claude Code conversation as a markdown file under $HOME/cclogs/{slug}/ for later reuse (memos, blog drafts, esa). Use when: (1) User says 'log conversation', 'record conversation', 'log-conversation', 'start logging', 'stop logging', (2) User invokes /log-conversation directly with args like -a, --all, -e, --end, or a number, (3) User wants to snapshot the chat to articlify or quote later.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Log Conversation
Save the current session transcript as a pair of markdown files in `$HOME/cclogs/{slug}/`
(same directory other skills use — see `logrefer`). The skill is session-scoped: state lives in
`$HOME/cclogs/{slug}/.log-conversation-state.<sessionId>.json`, so multiple concurrent sessions
do not collide.
Two files are written on each save (sharing the same timestamp base):
- `{stamp}-conversation.md` — **conversation only**: user + assistant text turns, no tool calls,
no tool results, no thinking blocks. Optimized for human reading and reuse in articles/memos.
- `{stamp}-conversation.raw.md` — **full raw transcript**: everything in the conversation file
plus thinking blocks, `tool_use` blocks with arguments, and `tool_result` blocks.
## Arguments ($ARGUMENTS)
Parse `$ARGUMENTS` into these flags (all optional, none required):
| Token | Meaning |
|---|---|
| `-a` / `--all` | Start a new log from the first user turn in the session |
| An integer `N` (e.g. `3`) | Start a new log from the Nth-most-recent user turn (1 = current) |
| `-e` / `--end` | Finalize: refresh the active log once more, then clear state |
If both `-a`/`N` and `-e` are given: start fresh AND finalize in a single shot (one-off save,
no persistent state).
If no args are given:
- If an active log already exists for this session → **refresh** it (overwrite with latest content).
- If no active log exists → **start** a new one from the current user turn.
## Workflow
### Step 1: Decide command and call the script
Pick the subcommand based on flags + whether state exists. Check state first:
```bash
node $HOME/.claude/skills/log-conversation/scripts/log-conversation.mjs status \
--session "${CLAUDE_SESSION_ID}"
```
Exit code `0` = active, `1` = no active log. Then dispatch:
| Situation | Command |
|---|---|
| No args, no active state | `start` (default: from current user turn) |
| No args, active state exists | `refresh` |
| `-e` only, active state exists | `end` |
| `-e` only, no active state | `start --end` (snapshot from current turn, one-shot) |
| `-a` / `--all` | `start --all` (add `--end` if `-e` also given) |
| `N` (integer) | `start --n N` (add `--end` if `-e` also given) |
Invocation:
```bash
node $HOME/.claude/skills/log-conversation/scripts/log-conversation.mjs <cmd> \
--session "${CLAUDE_SESSION_ID}" \
[--n N] [--all] [--end]
```
The script prints a JSON line like:
```json
{ "action": "start",
"logFile": "/Users/.../cclogs/slug/20260422_110000-conversation.md",
"rawLogFile": "/Users/.../cclogs/slug/20260422_110000-conversation.raw.md",
"startUuid": "…", "entries": 73, "ended": false }
```
`logFile` is the conversation-only `.md`; `rawLogFile` is the full transcript `.raw.md`.
Both files are rewritten on every `start` / `refresh` / `end`.
### Step 2: Report to the user
Report a short status with the absolute `logFile` path (and optionally `rawLogFile`). Mention
whether the log is now active (will be refreshed on next invocation) or finalized (state cleared).
Do not dump the file content to chat — the file is the point.
### Step 3 (optional): Open the file
If the user asks to see the log, use Read on the returned `logFile` (conversation only) or
`rawLogFile` (full transcript) path.
## Script Reference
`scripts/log-conversation.mjs` supports these subcommands (session ID via `--session` or
`$CLAUDE_SESSION_ID`):
- `start [--n N | --all] [--name NAME] [--end]` — create state, write log; `--end` deletes state after write (one-shot).
- `refresh` — rewrite the existing log from state.
- `end` — refresh + delete state.
- `status` — print active state as JSON (exit 1 if none).
The conversation log filename is `{YYYYMMDD}_{HHMMSS}-conversation[-name].md`, with the raw
counterpart `{YYYYMMDD}_{HHMMSS}-conversation[-name].raw.md` written alongside it. Once set
on `start`, the same paths are reused on every `refresh` / `end` for that session.
## Notes
- The current assistant response (the one generated by this invocation) is not yet in the transcript file when the script runs, so the final turn will be missing. The next invocation (or re-running `end`) picks it up. This is fine for typical use.
- Sidechain (subagent) turns are excluded so the log stays focused on the main conversation.
- Meta user messages (caveats, attachment markers) are kept but tagged `_(meta)_` in the log.
- State is per-session; `/clear` does not wipe state files — invoke `-e` to tidy up, or let old state files linger harmlessly in `$HOME/cclogs/{slug}/`.Related Skills
zudoesa-articlify
Convert conversation context into an esa article via the zudoesa-writer subagent. ONLY invoke when the user explicitly asks — NEVER proactively propose. Triggers: 'write esa article', 'esa記事', 'esaに書いて', 'articlify for esa', or /zudoesa-articlify. Gathers context, creates a writing brief, delegates to the writer subagent.
zudoesa-apply-voice
Apply Takazudo's esa writing voice and vocabulary rules to text. Use when: (1) User wants to write/rewrite text in Takazudo's esa style, (2) User says 'apply voice', 'esa voice', 'esa文体で', 'esa風に書いて', '文体を適用', (3) User provides text to transform to esa style. Reads writing-style.md and vocabulary-rule.md from takazudo-esa-writing repo and applies the rules.
zudocg-articlify
Convert conversation context into a CodeGrid article via the zudocg-writer subagent. ONLY invoke when the user explicitly asks — NEVER proactively propose. Triggers: 'write codegrid article', 'CodeGrid記事', 'codegridに書いて', 'articlify for codegrid', or /zudocg-articlify. Gathers context, creates a writing brief, delegates to the writer subagent.
zudocg-apply-voice
Apply Takazudo's CodeGrid writing voice and vocabulary rules to text. Use when: (1) User wants to write/rewrite text in Takazudo's CodeGrid style, (2) User says 'apply voice', 'codegrid voice', 'codegrid文体で', 'codegrid風に書いて', '文体を適用', (3) User provides text to transform to CodeGrid style. Reads writing-style.md and vocabulary-rule.md from takazudo-codegrid-writing repo and applies the rules.
zpaper-articlify
Convert conversation context into a zpaper blog article via the zpaper-writer subagent. ONLY invoke when the user explicitly asks — NEVER proactively propose. Triggers: 'write zpaper article', 'zpaper記事', 'zpaperに書いて', 'articlify for zpaper', or /zpaper-articlify. Gathers context, creates a writing brief, delegates to the writer subagent.
zpaper-apply-voice
Apply Takazudo's zpaper blog writing voice and vocabulary rules to text. Use when: (1) User wants to write/rewrite text in Takazudo's zpaper style, (2) User says 'apply voice', 'zpaper voice', 'zpaper文体で', 'zpaper風に書いて', 'ブログ文体を適用', (3) User provides text to transform to zpaper style. Reads writing-style.md and vocabulary-rule.md from the zpaper repo and applies the rules.
xlsx
Spreadsheet creation, editing, and analysis. Use when working with .xlsx, .xlsm, .csv, .tsv files for: (1) Creating spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modifying existing spreadsheets while preserving formulas, (4) Data analysis and visualization, (5) Recalculating formulas.
x
Facade for development workflows. Routes on two axes: plan-first vs implement-now (escalates to /big-plan -a when the request needs research / decomposition / has unclear scope — the appended -a makes the plan chain into implementation in-session), then single vs multi on the ready-to-build fast paths (/x-as-pr single-topic, /x-wt-teams multi-topic parallel). Use when: (1) User says '/x' followed by dev instructions, (2) User wants to start development without choosing the workflow skill, (3) User says 'dev', 'implement', or 'build' with a task. Default option: -v (verify-ui). Review-loop (-l) is opt-in — without -l the downstream skill runs a single /deep-review pass. Forwards -a (autonomy/auto-chain) and -m (merge at the end + cleanup + CI watch) through every route; auto-fix of raised findings (-f) and issue-raising (-ri) are downstream defaults, with -nf/--no-fix and -nori/--no-raise-issues as the forwarded opt-outs. -a and -m are orthogonal — full hands-off end-to-end is -a -m.
x-wt-teams
Parallel multi-topic development using git worktrees, base branches, and Claude Code agent teams. Use when: (1) User wants to work on multiple related features in parallel, (2) User mentions 'worktree', 'base branch', 'parallel development', 'split into topics', or 'multi-topic'. FULLY AUTONOMOUS — creates worktrees, spawns teams, coordinates everything. Also supports Super-Epic child mode for [Epic] issues from /big-plan with '**Super-epic:** #N' markers (targets the super-epic base branch instead of main).
x-as-pr
Start a development workflow as a draft PR. Creates a NEW branch from the current branch, empty start commit, draft PR targeting the current branch, then implements. ALWAYS creates a new branch by default — produces a nested PR-on-PR when the current branch already has one. Use when: (1) User says 'dev as pr', (2) User wants a PR-first workflow before coding, (3) User passes -s/--stay to reuse the current branch instead of nesting, (4) User passes a GitHub issue URL to implement, (5) User passes --make-issue/--issue to create an issue first. Logs progress via issue comments when an issue is linked.
watch-ci
Watch GitHub PR CI checks in the background and notify on completion. Use when: (1) User wants to monitor CI/CD status, (2) User says 'watch CI', 'check CI', 'monitor checks', or 'wait for CI', (3) User wants to know when checks pass or fail. Runs a background gh polling shell loop (NOT a subagent — near-zero token cost), sends macOS notification on completion. Also handles merged PRs by watching the target branch CI.
w-update-wording-rule
Add or update wording rules (表記ルール) in the w repo's vocabulary-rule.md files. Use when: (1) User says 'add wording rule', 'update wording rule', '表記ルール追加', (2) User wants to add a kanji/hiragana usage rule, (3) User provides a rule like 'X should be Y' with examples.