Clip Thread

---
name: clip-thread
description: 'Capture a chat or email thread from a connected MCP to the knowledge intake. Use when user says "/aria-cowork:clip-thread" or "archive this conversation". Pulls thread content from ~~chat (Slack, Teams) or ~~email (Gmail, MS365) MCP into intake/clippings/ for review. (Cowork variant — namespaced-only.)'
argument-hint: <thread-url-or-id> [tags]
---

# /clip-thread — Capture Chat/Email Thread to Intake

> **RETIRED 2026-08-19 (cowork v1.7.0).** Folded into `/aria-cowork:intake`: thread → `/aria-cowork:intake thread <id|url>`, or just paste a Slack/Teams/Gmail URL and it auto-detects (steps T1–T5). Kept for reference only — not a live skill (archived under `skills/.archived/`, excluded from discovery and from the summed-description budget). The five steps below were carried into `/intake` in full rather than compressed, because a threaded conversation loses its meaning when flattened into a snippet body. Mirrors canonical's v2.33.0 retirement.

Save a chat thread or email conversation to `intake/clippings/{YYYY-MM-DD}-{slug}.md` for review and promotion. Unlike `/clip` (URL/snippet) or `/intake` (bulk/doc-anchored), `/clip-thread` is shaped specifically for *threaded* conversations — Slack threads, Teams channel discussions, Gmail conversation chains, MS365 email threads.

## Runtime Gate (per ADR-094)

**Canonical resolution:** This is the Claude Cowork variant — namespaced-only. When both `plugin-claude-code` and `plugin-claude-cowork` are loaded in the same session (most common in Claude Desktop), bare `/clip-thread` resolves to aria-knowledge's variant — Code is the canonical owner of all 24 dual-port skills per ADR-094 §Part 1. To reach this skill, use the namespaced form: `/aria-cowork:clip-thread`. Do NOT match bare `/clip-thread` — that belongs to aria-knowledge.

**Before Step 0:** Check whether the `Bash` tool is available in this session. If `Bash` IS available (you are running in Claude Code or another runtime with shell access), surface the following notification and wait for explicit user confirmation:

> ⚠️ **Runtime mismatch — you invoked aria-cowork's `/clip-thread` from a runtime with shell access.**
>
> This skill is Cowork-native because it depends on ~~chat / ~~email MCPs that are typically only connected in Cowork. If you're in Code and DO have these MCPs configured there, fine to proceed; otherwise the canonical aria-knowledge variant at `/clip-thread` will at least surface the same gate.
>
> **Use `/clip-thread` instead?** (`y` / `n`)

Wait for an explicit reply:

- **`y` / `yes`** — Use the `Skill` tool to invoke `clip-thread` (the bare-slash canonical, which routes to aria-knowledge when both ports are loaded) with the same arguments the user provided to this invocation. Do not proceed with this skill's steps; the aria-knowledge variant takes over and runs to completion. This is the default-yes path — auto-redirect is the helpful action.
- **`n` / `no`** — Proceed with this (aria-cowork) variant anyway despite the runtime mismatch. The user has explicitly opted in.
- **No response / any other reply** — Treat as "do not proceed" and exit cleanly without running either variant.

**This gate applies even when `mode = auto`** per ADR-094 §Part 3. Auto mode's "implicit-yes on all gates" rule is suspended for the runtime-mismatch check — auto trusts that the user invoked the correct variant, and this gate enforces that precondition. All other auto-mode gates remain bypassed. The friction cost is now low: on `y`, the auto-redirect runs the correct variant with the original args.

If `Bash` is NOT available (normal Cowork runtime), proceed to Step 0.

## Step 0: Resolve config

The default knowledge folder is `~/Projects/knowledge/` (expand `~` to your home directory's absolute path). Read `<knowledge_folder>/aria-config.md` and extract `knowledge_folder` (the absolute path).

If `aria-config.md` doesn't exist, stop with: *"aria-cowork is not configured. Run `/aria-setup` to get started."*

Verify `<knowledge_folder>/intake/clippings/` exists. If not, stop with: *"Clippings directory not found. Run `/aria-setup` to repair the knowledge folder structure."*

For all subsequent file operations in this skill, use the absolute path from `knowledge_folder` directly. Cowork resolves absolute paths via the persistent grant from `claude_desktop_config.json` per ADR-008. aria-knowledge in Code uses the same absolute path to reach the same files.

## Step 1: Probe Connected MCPs

Check Claude's available tool list for `~~chat` and `~~email` MCPs. The skill needs at least ONE of these connected to proceed.

- **`~~chat`** (slack, ms365): if connected, available for Slack threads or Teams channel messages.
- **`~~email`** (gmail, ms365): if connected, available for Gmail or MS365 email threads.

If NEITHER category has a connected MCP, output the standard fallback notice and stop:

> No required MCPs connected for `/clip-thread`. Connect one of: Slack, Microsoft 365 Teams (for ~~chat) or Gmail, Microsoft 365 Outlook (for ~~email) via Cowork Settings → Connectors (or Claude Code's `.mcp.json` for the Code surface). See [CONNECTORS.md](../../CONNECTORS.md). Skipping this run.

Per ADR-015 (`{knowledge_folder}/projects/aria-cowork/decisions/015-capability-probe-pattern.md`), the runtime tool list IS the probe — no explicit API call needed.

## Step 2: Parse Input

The user provides one of:

- **A Slack thread URL** — `https://<workspace>.slack.com/archives/<channel>/<message-ts>` or thread permalink
- **A Teams message link** — `https://teams.microsoft.com/l/message/...`
- **A Gmail thread ID or URL** — `https://mail.google.com/mail/u/0/#inbox/<thread-id>` or just the thread ID
- **An MS365 message ID** — opaque ID from Outlook
- **A bare thread/conversation identifier** — opaque string the connected MCP can resolve

Optionally followed by tags (e.g., `slack #engineering`, `email customer-feedback`).

**Source-type detection:**

| Input shape | Routes to |
|---|---|
| Contains `slack.com/archives/` | `~~chat` (slack) |
| Contains `teams.microsoft.com` | `~~chat` (ms365) |
| Contains `mail.google.com` or matches Gmail thread-ID pattern | `~~email` (gmail) |
| Outlook-shaped ID | `~~email` (ms365) |
| Ambiguous | Ask user which category to route through |

If the detected category's MCP is NOT connected, output the category-specific fallback notice and stop:

> This thread looks like a [Slack thread / Gmail thread / etc.] but the `~~chat` / `~~email` MCP for that source is not connected. Connect [vendor] via Cowork Settings → Connectors and retry. Skipping this run.

## Step 3: Fetch Thread Content

Call the appropriate MCP tool to retrieve the thread:

- **Slack:** use the connected slack MCP's `conversations.replies` (or equivalent) tool with the channel + thread_ts derived from the URL. Retrieve all messages in the thread.
- **Teams:** use the connected ms365 MCP's message-thread tool.
- **Gmail:** use the connected gmail MCP's `messages.get` for each message in the thread (or `threads.get` if exposed).
- **MS365 Outlook:** use the ms365 MCP's email-thread tool.

For each message in the thread, gather:
- Author (display name + handle/email)
- Timestamp (ISO format)
- Body (plaintext if available, markdown if the source supports it)
- Reactions / attachments (if exposed — note their presence but don't fetch attachment bodies in this skill)

**Limit:** if the thread has more than 50 messages, fetch the first 50 + note the truncation in the clipping. The user can run `/clip-thread` again with a refined identifier for the tail.

## Step 4: Compose Clipping

Slug-ify the thread for the filename: use the first message's first ~6 significant words, lowercased, hyphen-separated, ASCII-only.

Generate the date stamp as `YYYY-MM-DD` (local time).

Filename: `intake/clippings/{date}-{slug}.md`

If a file with that name already exists, append `-2`, `-3`, etc. to deduplicate.

Body template:

```markdown
---
source: <thread-url-or-id>
source_type: <slack|teams|gmail|ms365>
date: <YYYY-MM-DD>
participants: [<list of unique authors>]
message_count: <N>
tags: [<from input args, plus auto-detected like 'slack' or 'email'>]
---

# <thread topic — extracted from first message's first line or the channel name>

## Context

- **Source:** <source URL or "Slack thread in #channel" / "Gmail thread with N replies">
- **Participants:** <N authors>: <list>
- **Spans:** <first-message-date> → <last-message-date>
- **Message count:** <N> (or "<N> of <total> — truncated at 50")

## Thread

<for each message:>

### <Author> — <timestamp>

<message body, lightly cleaned (remove Slack/MS markup if obvious, preserve markdown)>

<reactions if present: e.g., "Reactions: 👍 ×3, 🎉 ×1">

<attachment notes if present: e.g., "[attachment: deploy-logs.txt (45KB)]">

---

## Reaction

<intentionally left empty — the user's reaction / why this is worth keeping. /audit-knowledge surfaces this for review at next audit pass.>
```

## Step 5: Write + Report

Write the composed clipping to `<knowledge_folder>/intake/clippings/{date}-{slug}.md`.

Report to user:

```
Clipped <N> messages from <source-type> thread to intake/clippings/<date>-<slug>.md.

- Participants: <list, max 5 + "and N more" if truncated>
- Spans: <date range>
- Tags: <from input>

Next: review at next /audit-knowledge run. Add a reaction in the "## Reaction" section if you want to lock in the why-it-matters context now.
```

## Rules

- **Never auto-promote.** Clippings stay in `intake/clippings/` until `/audit-knowledge` routes them. This skill is intake-only.
- **Never delete the source.** Reading a thread via MCP doesn't modify it; this is read-only externally.
- **Respect 50-message truncation cap.** Do NOT loop and fetch all pages. If user wants the full thread, they can re-invoke with a refined scope or use the source platform's native export.
- **Strip secrets if obvious** — if the thread contains what look like API keys, OAuth tokens, or passwords (regex match against common patterns), replace with `[REDACTED]` in the body and add a `redactions: true` field to frontmatter. Surface in the report.
- **One thread per invocation.** If the user wants multiple threads, suggest `/intake` bulk mode.

## Notes

- Composes with `/audit-knowledge` — clippings written here are routed at next audit per the standard intake-disposition vocabulary (Accept → tracker / roadmap / todo / adr / plan / bundle / rule, or Reject / Defer).
- The `## Reaction` section is the user's voice slot. `/clip-thread` never fills it (the same precedent `/intake doc` set in v2.17.0 / v0.3.0).
- This skill is **bidirectional** per ADR-014 (`{knowledge_folder}/projects/aria-cowork/decisions/014-bidirectional-feature-flow.md`) — aria-knowledge v2.18.0 ships an identical body. Output schema is byte-identical per ADR-013 (`{knowledge_folder}/projects/aria-cowork/decisions/013-cowork-modified-skills-schema-identical-outputs.md`).
- Probe semantics per ADR-015 (`{knowledge_folder}/projects/aria-cowork/decisions/015-capability-probe-pattern.md`).