by-carlos/daikenja / skills/thread
thread
VerifiedReads a Slack or email thread, summarizes what is being asked and by whom, then collects context from the user before any reply is drafted. Use when the user pastes a thread link or a block of chat history, or says "help me answer this". It gathers only and never writes the reply.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 14.4 KB |
SKILL.md
View on GitHub---
name: thread
description: Reads a Slack or email thread, summarizes what is being asked and by whom, then collects context from the user before any reply is drafted. Use when the user pastes a thread link or a block of chat history, or says "help me answer this". It gathers only and never writes the reply.
metadata:
owner: Carlos
version: 3
pairs-with: compose
---
# Thread reply
Phase one of a two-phase workflow. This skill builds the picture. The
`compose` skill writes the message.
## Hard rule: do not draft
**Do not write a reply, a draft, or a suggested wording while this skill is
running.** Not even a short one. Not even if the answer looks obvious.
The real gate is the intent block in Step 5: never draft before it exists with
a real `Position` and a real `Ask`, both something other than `not stated`.
Until then, you gather and you wait, no matter how the user phrases it.
If you think you have enough to draft, say so in one line and stop:
"I think I have enough. Run /daikenja:compose when you are ready."
## Step 1: get the thread
- **A link was given.** Use the available Slack or email tools to fetch the full
thread, including the parent message and every reply. Do not work from the
permalink text alone.
- **Text was pasted.** Use it as-is. Do not go looking for more.
- **Nothing was given.** Ask for a link or a paste. Do not search for it.
If a fetch fails, say what failed and ask for a paste. Do not guess at the
content.
## Step 2: summarize it
Keep this to about 5 lines. The block below follows
`${CLAUDE_PLUGIN_ROOT}/docs/response-format.md` -- read it before writing the
reply; the summary is the answer and nothing precedes it. § The second person
belongs to conversation decides whether `Waiting on` carries a name or `you`.
```
🧵 **Thread** -- [what it is about, who is in it, and how many messages]
❓ **Asking** -- [who is asking, and what they actually want]
🔓 **Open** -- [what is still undecided]
⏳ **Waiting on** -- [name: what is theirs]
📒 **Ledger** -- [what the project already has on this -- see Step 2b]
🌡️ **Tone** -- [neutral / tense / urgent -- only if it is not neutral]
```
**The `Thread` line is about the thread, never about how it arrived.** Lead
with what the thread is about, then who is in it, then the count. Never name
the input mechanism -- not `pasted block`, not `link`, not `forwarded` -- and
never state an absence. A channel that is not known is simply not mentioned;
`channel not stated` is a defect, not a disclosure.
**`Waiting on` names the person**, per `${CLAUDE_PLUGIN_ROOT}/docs/response-format.md`
§ The second person belongs to conversation. In this reply, where there is one
reader, `you` is that person's name and is correct. In any form that leaves the
session, the name is written out -- see § Form `message`, which is how a caller
asks for that form.
**`Tone` is written in this reply only.** Any form that leaves the session omits
it, empty or not: it exists to feed the draft `compose` writes, and a consumer
that never reaches `compose` gains nothing from a bot publicly labelling
someone's message `tense`.
**The summary block is never wrapped in a code fence and never contains one**,
even when the thread itself quotes a fenced snippet -- a config block, a stack
trace, a code sample. A quoted line is named or restated inline, not fenced.
**A line that wraps onto a second line indents the continuation.** A second
line that starts at the margin, with no indent, ends the block for a
consumer that finds it by shape.
Attribution rules, because getting this wrong is expensive:
- Name who said what. Do not merge two people's positions into one.
- Separate a **question** from a **proposal** from a **decision**. If someone
suggested something and nobody agreed, it is a suggestion, not a decision.
- If a position is ambiguous, say it is ambiguous. Do not resolve it for them.
- Quote sparingly and only when the exact wording matters.
**Do not flag ordinary workplace content.** Names, roles, opinions,
disagreements and performance concerns are the normal subject matter of a
thread the user is already part of. Handle them like any other content.
The one exception: if a credential, token, connection string or password appears
in the thread, say so in one line and never copy it forward. That is a security
matter, not a privacy one.
## Step 2b: place the thread
A thread is rarely the first thing a project has heard about its subject. If
the project keeps a ledger, what it already decided, what is still open, and
whether this thread contradicts any of it belongs in the summary -- otherwise
the user is asked to supply from memory what is already written down. This
step reads; it never writes. **`project-log` is the only skill that writes a
ledger, and nothing here changes that** -- a decision the thread seems to
make is reported here and logged, if at all, by the user through
`/daikenja:project-log` afterwards.
**Find the project**, in the order `${CLAUDE_PLUGIN_ROOT}/docs/config-resolution.md`
§ Finding the project fixes, and stop at the first that resolves:
1. **A key the user named** -- "help me answer this, it's harbor" -- per
`${CLAUDE_PLUGIN_ROOT}/docs/reading.md` § Step A0. Decisive; never falls
back. An unknown key is reported with the registered keys and this step
ends without a project.
2. **The current directory**, per `reading.md` § Step A. The user is standing
in a project; that is the project.
3. **The thread's content**, per `${CLAUDE_PLUGIN_ROOT}/docs/project-card.md`
§ Resolving a project by content: the channel it came from, a tracker key
or repository it names, then its subject against every registered card's
Scope. Only a handle match is a match, and the `Ledger:` line says how it
was found -- `matched by #harbor-rollout` -- since the user did not name
it and is not standing in it. **A Scope fit is not a match and is never
asked about**, per that section's tier 2.
**Never ask which project applies.** Summarize the thread first, and put the
project question at the end of it as an offer the person can take or ignore.
When no handle decided, no ledger is read. Whether the summary then says so
is the rule below under "When no project resolved" -- in a conversation it
stays silent, and for a caller whose output leaves the session the `📒 Ledger`
line carries which project was assumed instead of a finding, in one of two
fixed forms:
```
No ledger read. This looks like <project name> -- say `<command> project <key>` to check it.
No project context. Add `<command> project <key>` if you want a ledger checked.
```
The first when a card's Scope nearly matched, the second when nothing did.
The caller says how `<command>` is written; for the Slack bot it is
`@daikenja summary`. **The sentence is copied, not composed** -- a rule
phrased as "name the candidate" produced a question in a real run instead,
and a rule that allowed the question anywhere produced it here.
When a key or a directory resolved, still run the content check as a
**cross-check**: a decisive handle on a *different* project's card is
reported as a mismatch (`This thread is from #atlas-dev, which belongs to
atlas-migration, not to harbor`), and the summary goes on with the project
the user is in. The user may be answering a neighbouring project's thread on
purpose; the line makes sure it is on purpose.
**Read what the project has**, per `reading.md` § Step B and § Step C: the
`DECISIONS.md` of every registered repository, the Open items of `open.md`,
and the card beside `open.md` if there is one. Then write the `Ledger:` line:
- **Decisions the thread touches** -- topic first, cited by their words and
the repository whose `DECISIONS.md` holds them, per
`${CLAUDE_PLUGIN_ROOT}/docs/response-format.md`. There are no IDs.
- **Decisions the thread contradicts**, named as such: "contradicts the
Saturday cutover decision (harbor)". A proposal in the thread that runs
against a decision in force is the most useful thing this line can say.
- **Open items the thread bears on**, and whether the thread appears to
resolve one -- reported as "appears to resolve", never as resolved, since
only `project-log` can do that and only on the user's say-so.
```
📒 **Ledger** -- harbor (C:/GitHub/harbor/DECISIONS.md, C:/GitHub/harbor/.daikenja/open.md):
touches the ramp cutover decision (harbor); the proposed Friday start
contradicts its Monday 2026-08-17 date; appears to resolve the open
rollback-trigger question.
```
Keep it to one or two lines. Naming the project and the files read is what
makes the rest checkable, so both stay even when nothing matched:
`📒 **Ledger** -- harbor (<files>): nothing on this subject.` is a complete,
useful line. `<files>` follows `reading.md` § Step B: every file read,
absolute, a missing one marked `(not created yet)`.
**Project data unreadable.** A project that **needs migration**, per
`reading.md` § Step A and § Step B, gets that notice line in place of the
`Ledger` line, and nothing is read. A file with a **newer format version**,
per `${CLAUDE_PLUGIN_ROOT}/docs/open-format.md` § Version line, is read
anyway with its one warning. The `message` form below handles both
differently.
**When no project resolved**, or the project has none of the files, leave the
`Ledger` line out and say nothing about it. A thread that is not project
work is the ordinary case, and `daikenja.yaml` being absent is not a reason
to narrate configuration in the middle of a thread summary. The only notices
this step ever adds on its own are the mismatch above and, **for a caller
whose output leaves the session, the sentence saying which project was
assumed** -- either of the two fixed forms above, whether a card nearly
matched or nothing did. That caller keeps the `Ledger` line for it, because a
reader who was not in the session needs to be told what was and was not read.
## Form `message`: a summary that leaves the session
`/daikenja:thread` produces the conversational reply above, for the one
person reading it. **`/daikenja:thread message`** produces the Step 2 block as
a deliverable for a surface where that person is not the only reader -- a bot
posting into a channel, a block pasted somewhere else. A caller with an
enclosing thread of its own passes that thread as the subject and names this
form; nothing here assumes a working directory or a terminal.
The block keeps its shape and its attribution rules exactly. Three things
differ, and nothing else does:
- **People are named, never `you`**, per
`${CLAUDE_PLUGIN_ROOT}/docs/response-format.md` § The second person belongs
to conversation. `⏳ **Waiting on** -- you: an answer on the duration` is
precise in a reply and has no referent in a channel, where every reader is
a `you`. Step 2's allowance for `you` is about the reply and does not reach
this form. A person whose name cannot be resolved is described by what they
did -- "the person who raised it" -- and never falls back to `you`.
- **`Tone` is omitted**, empty or not, per Step 2.
- **The `Ledger` line names the project, not the path.** Step 2b's line
carries absolute paths, which carry the machine's own username; a reader
in a channel cannot open them and should not be shown them.
`📒 **Ledger** -- harbor: touches the ramp cutover decision (harbor).`
**Project data unreadable produces no summary.** When the project needs
migration or a file carries a newer format version, the deliverable is
exactly one line, copied, with nothing before or after it -- the same token
`judgement` uses:
```
DAIKENJA-PROJECT-DATA-UNREADABLE <key> needs-migration
DAIKENJA-PROJECT-DATA-UNREADABLE <key> newer-format
```
`<key>` is the project key, or `-` for an unregistered directory. Step 2b's
notice line goes in the report around it, never in the deliverable.
The block is the whole deliverable. Steps 3 to 5 do not run: there is nobody
in the session to ask for a position, so there is nothing to hand off and
nothing to draft. The hard rule at the top holds here as everywhere.
## Step 3: get the user's position
You cannot write a reply for someone whose position you do not know. If the user
has not said what they want to happen, ask. Keep it to 1 or 2 questions:
- What outcome do they want from this reply?
- Is there a position they are holding, or are they asking a question?
Do not ask more than two questions at a time. Do not ask about tone yet.
## Step 4: keep gathering
The user will keep adding context over several messages -- background, history
with the people involved, constraints, things that happened offline, links to
other threads.
Each time:
- Fold it into what you already have.
- Say in one line what changed, if anything material changed.
- If the new information contradicts the thread, point that out.
- If the new information contradicts a ledger decision Step 2b read, point
that out too, naming the decision. Do not log anything -- offer
`/daikenja:project-log` once if the user seems to be making a new decision,
and leave it there.
- If something is still missing that would change the reply, name it once. Do
not keep asking.
Do not restate the whole summary every turn.
## Step 5: hand off
When the user invokes `/daikenja:compose`, or says in plain words that they are
ready ("draft it", "go ahead", "that's everything"), produce the intent block
below, then follow that skill. Do not produce this block earlier.
```
INTENT BLOCK
Audience: [who reads it -- peer / manager / leadership / engineers / external]
Channel: [#channel name, DM, or email]
Goal: [inform / request / state a decision / push back]
Position: [what the user is actually saying, in their words where possible]
Ask: [the single thing the reader should do, and by when if stated]
Constraints: [anything that limits the wording]
Risks: [escalation, HR, security, or a technical claim worth checking]
```
Anything not established goes in as `not stated`. Do not fill a gap with a guess.
If `Position` or `Ask` is `not stated`, ask for it before drafting.
A decision Step 2b found the thread contradicts, and the user did not
address, goes under `Risks` -- "the reply runs against the Saturday cutover
decision (harbor)" -- so `compose` carries it into the draft's caveats rather
than losing it at the handoff.
## What this skill does not do
- It does not write the ledger, the project card or `daikenja.yaml`. Step 2b
reads; `/daikenja:project-log` writes, on its own approval.
- It does not register a project it could not resolve, and it does not
create a card for one that has none. `/daikenja:setup-project` does both.
- It does not draft. That rule is at the top of this file and Step 2b does
not soften it.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| add-product-e2e-evalpaperclipai/paperclipAdd or extend a Paperclip full-stack runner E2E workflow, fixture, matcher, or report evidence path for local or Daytona execution. | Stars: 115k | Updated | Claude CodeCodex | Verified | Install |
| add-runner-evalpaperclipai/paperclipAdd or extend a Paperclip Runner protocol evaluation definition, roster, assertion, or report fixture with provenance and narrow validation. | Stars: 115k | Updated | Claude CodeCodex | Verified | Install |
| diagnose-why-work-stoppedpaperclipai/paperclipCompatibility entry point for failed, stalled, looping, or over-recovered Paperclip work. Use fix-failed-paperclip-run for the full diagnosis, regression, repair, real verification, and green-PR workflow; honor an explicitly requested diagnosis-only scope. | Stars: 115k | Updated | Claude CodeCodex | Verified | Install |
| fix-failed-paperclip-runpaperclipai/paperclipDiagnose and fix failed, stuck, slow, or incorrectly blocked Paperclip tasks and runs. Use with a task/run URL or failure report to trace the root cause, prove a regression red then green, check second-order effects, verify the real workflow, and deliver a PR with passing checks. | Stars: 115k | Updated | Claude CodeCodex | Verified | Install |