narrative-convergence — Claude Code skill: features and setup

---
name: narrative-convergence
description: Cross-skill signal detector - finds entities or themes surfaced independently by 3+ different skill categories within 48h and surfaces them as high-confidence write opportunities
metadata:
  category: core
  var: ""
  tags:
    - content
    - meta
    - intelligence
---
> **${var}** — Optional entity or theme filter (e.g. "Anthropic", "coordination markets"). If empty, scans all skill output categories.

Today is ${today}. Read `memory/MEMORY.md` before starting.

## Voice

If `soul/SOUL.md` and `soul/STYLE.md` exist and are populated, read them and match the operator's voice when drafting the write angles and hook lines (step 5) and the notification. Otherwise use a clear, direct, neutral tone — short, declarative, position-first.

## Why this skill exists

`narrative-tracker` follows narratives inside one feed (crypto X) and tracks their phase. It works well when the narrative is already named.

This skill does something different: it detects **emergent cross-skill convergence** — when independent operational skills (security scanners, market trackers, sector pulses, etc.) all surface the same entity, company, protocol, or theme within 48h, without any prior coordination. That kind of convergence is a higher-signal indicator than any single source — it often precedes a breakout narrative. Example: a security skill flags a company's automated-vulnerability work, a social digest catches that same company announcing a major deal, and a market tracker notes a related fraud-prevention win — three independent skills, one entity, in 48h. That bleedthrough is the signal. This skill catches it automatically.

## Config

The signal-category map is **operator-editable** and lives in `memory/topics/signal-categories.md`. If the file doesn't exist, create the seed below and continue. The categories are what let the skill measure *cross-category* diversity (the core of the convergence score) — edit them to match the skills you actually run.

```markdown
# Signal Categories

## Housekeeping (excluded — no external signals)
heartbeat, memory-flush, aeon-doctor, aeon-update, auto-merge,
skill-health, skill-repair, self-improve, operator-scorecard,
shiplog, fleet-control, fork-fleet, narrative-convergence

## Signal categories (skill → category)
| Category | Skills |
|----------|--------|
| market | token-pick, token-movers, defi-overview, monitor-polymarket, pm-manipulation, unlock-monitor, picks-tracker |
| social | fetch-tweets, narrative-tracker, mention-radar, write-tweet, last30 |
| ecosystem | github-trending, github-monitor, bd-radar, competitor-monitor |
| onchain | onchain-monitor, investigation-report, tx-explain, base-mcp |
| security | vuln-scanner, vuln-tracker, sc-audit, inbox-triage |
| research | article, digest, you-web-search, glim-mcp, idea-pipeline, idea-forge |
| opportunity | hunter-22, feedback-builder, taskmarket-delegate |
```

## Steps

### 1. Identify which outputs to read

List `output/.chains/*.md` with the Glob tool. Exclude the **Housekeeping** skills from `signal-categories.md` — they carry no external signal.

Map each remaining output file to its category using the table in `signal-categories.md`. Any signal skill not listed in the table goes into an `other` category (so newly-added skills still count toward convergence, just without a named lane).

If `${var}` is set, note it as a filter hint but still read all outputs — apply filtering at the scoring step.

### 2. Read each signal skill's output

For each signal skill output file that exists:

1. Read the file (or first 600 chars if large — enough to get entities and theme).
2. Extract: **named entities** (companies, protocols, people, tokens, projects) and **key themes** (e.g. "DNS rebinding", "coordination markets", "compute commoditization").
3. Note the **skill name** and **category**.

Build an entity/theme map:
```
{
  "<Entity>": [{ skill: "vuln-scanner", category: "security" }, { skill: "fetch-tweets", category: "social" }],
  "<theme>": [{ skill: "monitor-polymarket", category: "market" }, ...],
  ...
}
```

Also read memory logs from the last 2 days (Glob `memory/logs/*.md`, take the 2 most recent). From each log, extract entities/themes mentioned in specific skill run entries and add them to the map with their source skill. Every skill appends a log entry, so the signal map can be reconstructed from logs alone when `output/.chains/` is sparse.

### 3. Score convergence signals

For each entity or theme, compute a **convergence score**:

| Criterion | Points |
|-----------|--------|
| Mentioned by 5+ independent skills | 10 |
| Mentioned by 4 skills | 7 |
| Mentioned by 3 skills | 5 |
| Mentioned by 2 skills | 2 |
| Spans 3+ distinct categories | +4 |
| Spans 2 distinct categories | +2 |
| All sources from 1 category | −3 |
| Matches a known operator interest (from `soul/SOUL.md`, if present) | +2 |
| Adjacent to operator interest | +1 |

**Minimum to include: 5 points.** Drop everything below.

If `${var}` is set, require the entity/theme to match `${var}` (substring, case-insensitive), or include it only if closely related.

Rank descending by score. Take top 5 (or fewer if <5 clear signals).

### 4. Check against recent article coverage

Glob `output/articles/*.md`, filter to the last 14 days. For each top signal:
- If an article covered this entity/theme in the last 7 days: suppress it (−10, effectively dropping it).
- If covered 8–14 days ago: note "recently covered" as a caveat.

Update the final ranking after suppression. (If no `output/articles/` dir exists, skip this step.)

### 5. Develop write opportunities

For each surviving top signal (minimum 2 signals to notify, else skip):
- State the **convergence story**: "3 independent skills surfaced X in 48h — [skill1] saw Y angle, [skill2] saw Z angle".
- Suggest a **specific write angle** that synthesizes the signals (operator voice if soul files present).
- Draft a **hook line**: short, declarative, position-first.

Example format:
```
<ENTITY> (score 11) — security + social + market
→ vuln-scanner: automated vuln-finding at scale; tweet-roundup: major platform deal; market-context: fraud-prevention win
→ angle: AI-finds-vulns is becoming industrial — not a research project, a service. who charges for it?
→ hook: "the vulnerability bounty economy just got automated"
```

### 6. Update memory

Write `memory/topics/convergence-signals.md` (overwrite if exists):

```markdown
# Convergence Signals — Last Updated: ${today}

## Active Signals (score ≥ 5)

### [Entity/Theme] — Score: N
**Sources (N skills, N categories):** skill1 (category), skill2 (category), ...
**Convergence story:** [what each source noticed, one line each]
**Write angle:** [specific take, not generic]
**Hook:** [suggested opener]
**Last article coverage:** [date or "never"]

[repeat for each signal]

---
*Generated by narrative-convergence on ${today}. Top signal has N source skills across N categories.*
*Consumed by: article skill.*
```

If no signals meet the threshold: write a minimal file noting the scan ran clean.

### 7. Send notification (only if ≥ 2 strong signals)

If fewer than 2 signals survive after suppression: skip notification. Log `NARRATIVE_CONVERGENCE_SKIP: no strong cross-skill convergence found today`.

Otherwise, write to `.pending-notify-temp/narrative-convergence-${today}.md` (create the dir if needed):

```
narrative convergence — ${today}

N entities surfaced by 3+ independent skills in 48h:

1. [entity/theme] — N skills × N categories — [hook in one line]
2. [entity/theme] — N skills × N categories — [hook in one line]
[up to 5]

these aren't single-source signals. they're bleedthrough.

full breakdown: memory/topics/convergence-signals.md
```

Keep under 900 chars. Run:
```bash
./notify -f .pending-notify-temp/narrative-convergence-${today}.md
```

### 8. Log to memory/logs/${today}.md

Append under a `### narrative-convergence` heading:
```markdown
### narrative-convergence
- **Skills scanned:** N
- **Entities/themes mapped:** N
- **Signals above threshold:** N
- **Top signal:** [entity/theme] (score N, N skills, N categories)
- **Notification:** sent / skipped
- NARRATIVE_CONVERGENCE_OK
```

If skipped: `NARRATIVE_CONVERGENCE_SKIP: <reason>`.

## Required Env Vars

None. All reads from local `output/.chains/`, `memory/`, and `output/articles/` dirs.

## Network Note

No network calls required. All data comes from local files written by other skills. If `output/.chains/` is sparse (e.g. first morning run before skills have written), fall back to reading the last 3 memory logs directly — every skill appends a log entry, so the signal map can be reconstructed from logs alone. The only outbound call is `./notify`, which works reliably.