/discordembed — compose a rich Discord EMBED-style writeup, copied to your clipboard

Take what was just figured out / produced in this chat and package it in Discord embed style — then put it on the clipboard, ready to paste yourself. Like /discordmsg, but using the embed formatting rules (bigger budget, bold headers, masked links, custom emoji tokens) instead of the plain-message rules. This skill never sends anything anywhere — no webhook, no auto-post. It only formats and copies.

Why embed style (vs a plain /discordmsg message):

• Embed formatting affords a bigger combined budget — description ≤ 4096, whole payload ≤ 6000 — good for a longer writeup than a normal Discord message allows.
• ##/### headers do not render inside an actual Discord embed → use **bold** section headers instead, regardless of where this text ends up.
• Masked [text](url) links and full-token custom emoji (<:name:id> / animated <a:name:id>) are written the same way whether this lands in an embed or gets pasted as-is.

Embeds are typically produced by a bot or webhook payload (a content-plus-embeds JSON post). This skill gives you the ready-to-drop-in text; how you turn it into an actual embed (a bot, a webhook tool, or a site that builds the payload) is up to you.

The embed format (rules of the output)

• ## / ### headers do NOT render inside an embed → use **bold** for every header/section label instead. (The #1 embed gotcha.)
• Lead with a one-line TL;DR, then bold-headed sections with - bullets. Overview first, detail second — written for a reader who was NOT in the chat.
• Emojis where they slap — one per section header + the odd inline accent (✅ done, 🐛 bug, 🔧 fix, ⚠️ caveat, 🚀 shipped, 📊 numbers, 🎯 goal). Plain unicode renders fine; relevant, not confetti. Custom server emoji must carry the full token <:name:id> (animated <a:name:id>) — the :name: shorthand does not expand outside the Discord client.
• Masked links work in embeds — [text](url) renders, so you may use them. Raw URLs work too.
• A title is optional — put it as a single bold line at the top of the text if used.
• Don't pad. A tight, scannable writeup beats a wall. Length serves clarity.

Audience note

Tailor the content to where it's going. If the destination is a shared team / work channel, keep it to status & progress — what's done / in flight / next — and don't assign work to others or air open problems as things needing attention. For a personal or casual channel, anything goes. (When in doubt, write a clean progress overview, not a task list.)

Character budget

DESC_CAP  = 4096    # one embed's worth of text
TOTAL_CAP = 6000    # if it must span two embeds worth (rare)

1. Compose the overview to fit one block ≤ 4096. That covers almost every writeup.
2. Only if it genuinely needs more → split into two blocks, separated by a clear --- (part 2) --- marker, keeping the total ≤ 6000.
3. If important attachment-style detail (full logs, raw numbers, code) overflows even 6000 → that isn't embed material; mention it in one line and spill it to a .txt instead (same overflow convention as /discordmsg).

Copy to clipboard (always)

1. Write the raw text (no surrounding fence) to a temp file, e.g. ${TMPDIR:-/tmp}/discord-embed.txt. Writing to a file (not a shell var) avoids emoji/quote escaping bugs.
2. Copy that file to the clipboard with whatever's available on this OS — try in order and use the first that exists:

   F="${TMPDIR:-/tmp}/discord-embed.txt"
   if   command -v pbcopy   >/dev/null; then pbcopy < "$F"                       # macOS
   elif command -v wl-copy  >/dev/null; then wl-copy < "$F"                      # Linux / Wayland
   elif command -v xclip    >/dev/null; then xclip -selection clipboard -i "$F"  # Linux / X11
   elif command -v xsel     >/dev/null; then xsel -b -i < "$F"                   # Linux / X11 (alt)
   elif command -v clip.exe >/dev/null; then clip.exe < "$F"                     # Windows / WSL
   else echo "no clipboard tool found — use the copy block below"; fi

3. ⚠️ Remote/SSH caveat — say this when it applies. If SSH_CONNECTION is set, the clipboard command writes to the remote machine's clipboard, which usually does not reach the user's local machine over plain SSH. In that case the copy-friendly fenced block (below) is their fallback — always print it too.

How to deliver it back to the user

Present the text inside a copy-friendly fenced block (belt-and-suspenders: the fallback when the clipboard can't cross SSH) so one select grabs the raw markdown:

````
**Title (optional)**
**🎯 TL;DR**
... the embed-style writeup ...
````

Then, below the block, in your normal reply (NOT inside the copy block):

• a line confirming the text is on the clipboard (+ the SSH caveat if it applies);
• one line confirming char count vs the budget (e.g. 1,694 / 4096 chars ✅);
• if a .txt overflow file was written, its absolute path + a one-line note on what's in it.

$ARGUMENTS

• Focus string (e.g. /discordembed the release notes) → summarize that, aimed at that audience/angle. A tone/length request ("short", "very detailed") overrides defaults (caps hold).
• No focus → summarize the most recent substantive result in the chat, as a general share.

Execution steps

1. Parse $ARGUMENTS → subject + audience/tone.
2. Draft the writeup in embed-style markdown using bold headers (NOT ##), TL;DR → bold-headed sections → bullets, emojis where they slap, outsider-readable, audience-appropriate. Fit it to ≤ 4096; only split into a second block if it truly needs the 6k budget.
3. Write the raw text to a temp file — ${TMPDIR:-/tmp}/discord-embed.txt.
4. Copy it to the clipboard (write to file → clipboard command → confirm), per the Copy to clipboard section. Flag the SSH caveat if SSH_CONNECTION is set.
5. Output the text in a copy-friendly fence; below it confirm it's on the clipboard, report the char count vs budget, and give any .txt overflow path.
6. Do not send anything anywhere and do not commit — this skill only formats and copies.