AI Framework Watch

> **${var}** — Optional. One framework name (e.g. `langgraph`, `crewai`) to scope the digest to a single framework's deep dive instead of the full watchlist sweep.

Today is ${today}. The AI agent framework space ships fast — LangGraph, CrewAI, AutoGPT, LlamaIndex, Mastra, smolagents, dspy, and Pydantic AI all push releases and breaking changes weekly. Operators running aeon (or any other agent stack) need a "what moved last week" anchor to spot protocol shifts (A2A adoption, MCP changes), feature gaps the fork ecosystem could close, and momentum signals that hint at where the broader ecosystem is heading. `github-trending` covers code broadly; `huggingface-trending` covers AI artifacts; this skill covers the **frameworks** layer specifically — the libraries operators actually build *on*.

Read `memory/MEMORY.md` for context.
Read the last 8 days of `memory/logs/` to dedupe framework picks already featured this week.
Read `soul/SOUL.md` + `soul/STYLE.md` if populated to match voice.

## Watchlist

Hardcoded set of 9 frameworks tracked every run. The list is intentionally curated — large enough to surface ecosystem-wide shifts, small enough to keep the digest scannable. Anchor (`aaronjmars/aeon`) sits at the top so deltas across runs read as "where does aeon stand vs. peers" rather than just "ecosystem snapshot."

| Slug | Repo | Surface |
|------|------|---------|
| aeon | aaronjmars/aeon | Anchor — agent-as-platform, GitHub-native runtime |
| langgraph | langchain-ai/langgraph | Stateful multi-agent orchestration |
| crewai | crewAIInc/crewAI | Role-based crew patterns |
| autogen | microsoft/autogen | Conversational multi-agent |
| llamaindex | run-llama/llama_index | RAG / data agents |
| mastra | mastra-ai/mastra | TypeScript agent framework |
| smolagents | huggingface/smolagents | Code-writing minimal agents |
| dspy | stanfordnlp/dspy | Declarative LM programs |
| pydantic-ai | pydantic/pydantic-ai | Type-safe agent framework |

If `${var}` matches a slug, the run produces a single-framework deep dive instead of the watchlist sweep (see step 9).

## Steps

### 0. Bootstrap

```bash
mkdir -p memory/topics articles
[ -f memory/topics/framework-watch-state.json ] || echo '{"frameworks":{},"last_run":null}' > memory/topics/framework-watch-state.json
```

### 1. Resolve scope

If `${var}` is set and matches a watchlist slug, set `MODE=deep_dive` and limit subsequent steps to that one framework. Otherwise `MODE=sweep` covers all 9.

If `${var}` is set but doesn't match any slug, log `AI_FRAMEWORK_WATCH_BAD_VAR`, send a brief notify (*"AI Framework Watch — unknown framework `{var}`, watchlist is: {slugs}"*), and exit.

### 2. Fetch repo metadata

For each framework in scope:

```bash
gh api "repos/${OWNER}/${REPO}" --jq \
  '{stars: .stargazers_count, forks: .forks_count, open_issues: .open_issues_count,
    pushed_at, default_branch, description, archived, language: .language,
    license: .license.spdx_id // "none"}'
```

If `gh api` fails:
- **404** → log `framework=unreachable` and drop from this run's table (continue with the rest)
- **403** rate-limit → retry once after 60s; persistent → mark `unreachable`
- **5xx** → retry once after 10s; persistent → mark `unreachable`

If `archived: true` → mark the framework with a deprecation flag, keep in the table once with a `[ARCHIVED]` tag, then drop from future runs (write `archived: true` to state so step 7 deltas don't re-flag it forever).

### 3. Fetch recent releases

For each framework, pull the last 5 releases (covers ~2 weeks of cadence for the most active frameworks):

```bash
gh api "repos/${OWNER}/${REPO}/releases?per_page=5" --jq \
  '[.[] | {tag_name, name, published_at, draft, prerelease,
           body_first_line: (.body // "" | split("\n")[0] | .[0:240])}]'
```

Filter for the **last 7 days** of releases by `published_at`. Skip drafts. Pre-releases (rc, beta, alpha) are kept but tagged `[PRE]` in the line.

If a framework has 0 releases in the 7-day window: that's normal, render `—` in the releases column.

### 4. Compute momentum signals

Read prior state from `memory/topics/framework-watch-state.json`. For each framework:

```
star_delta_7d = current_stars - state.frameworks[slug].stars_7d_ago
star_delta_30d = current_stars - state.frameworks[slug].stars_30d_ago  (if known)
issue_delta_7d = current_open_issues - state.frameworks[slug].open_issues_7d_ago
release_count_7d = number of non-draft releases in the 7-day window
```

If prior state is empty (first ever run), all deltas render as `—` and the run is tagged `COLD START` in step 6.

The 30-day delta is a rolling estimate: if the state has data ≥21 days old, use that; if state is younger, render `—` (don't extrapolate from the 7-day sample).

### 5. Detect breaking-change releases

For each release in the 7-day window, scan the `body_first_line` and `name` for breaking-change signals:

- **Strong signals** (always flag): `BREAKING:`, `BREAKING CHANGE`, `breaking-change`, `[BREAKING]`, `⚠️ BREAKING`
- **Major-version bump signal**: `tag_name` matches `v\d+\.0\.0` AND the prior release was on a different major (e.g. v3.x → v4.0.0)
- **Migration-flagged signal**: `body_first_line` contains `migration guide`, `migrate to`, `removed`, `replaced` (case-insensitive) AND a major or minor version bump

A release that fires any signal gets `[BREAKING]` in its line. If a framework ships ≥1 breaking release in the window, surface it in the verdict (step 6).

The detection is intentionally precise-over-permissive: false positives erode trust faster than false negatives in a digest format. If a release's body lacks a clear breaking marker but you have strong reason to suspect (semver-major + heavy churn), note it in the line as `(major bump — review changelog)` rather than firing `[BREAKING]`.

### 6. Pick the verdict (one-line lede)

Priority order:

1. `BREAKING WEEK: {N} frameworks shipped breaking releases — {names}` — if ≥1 BREAKING flag
2. `MOMENTUM SHIFT: {framework} — {N}