hive-skills 0.1.0

package/assets/skills/meta/ccs-skill-creator/composable/mini/00-core.md

@@ -0,0 +1,46 @@
+# CCS Skill Creator: Core
+
+## What CCS is
+
+Compiled Composable Skills (CCS) packages an agent skill as small
+authored markdown **minis** (one subtopic each), a knowledge-free **INDEX** that
+lists them with "load when" hints, an optional always-loaded **00-core** holding
+cross-cutting traps, and a tool-compiled **BUNDLE.md** (the deterministic
+concatenation of every mini) plus optional named **presets/**. The minis are the
+only source of truth; INDEX, BUNDLE, and presets are derived artifacts. The
+payoff: a task loads only the slice it needs, quality stays at least as high as a
+monolith, and every packaging choice is auditable. You build and check skills
+with one stdlib CLI, `tools/hive.py` (subcommands `compile`, `lint`, `parity`,
+`report`). This skill is itself authored in CCS format: the layout you are
+reading is the layout you produce.
+
+## Loading policy (how you consume any CCS skill, including this one)
+
+Read the INDEX first. Load `00-core` if the index marks one. Estimate coverage
+`k/N` = (minis relevant to the task) / (total minis). If `k/N` < ~0.6, load the
+`k` relevant minis individually. If `k/N` ≥ ~0.6, load `BUNDLE.md` (or a matching
+`presets/*.md`) in one read. Never both fan out to subagents and load the whole
+bundle for the same task.
+
+## The two iron rules
+
+1. **The index is a menu, not a meal.** `INDEX.md` carries none of the
+   skill's content, only mini filenames, terse descriptors, and "load when"
+   conditions. Any knowledge a mini needs in order to be applied lives *in the
+   mini*, never in the index.
+2. **Conversion is repackaging, never summarization.** Moving a skill into CCS
+   moves content between containers; it must not shrink it. Every fact,
+   threshold, table, and worked example survives verbatim-equivalent in some
+   mini. Runtime tokens are saved only by *selection* (load fewer minis) and
+   *dedup* (preamble shared across minis factored once into `00-core`), never by
+   cutting content.
+
+## When NOT to use CCS
+
+- **Under ~5k tokens of knowledge** → ship a single `SKILL.md`. The INDEX +
+  00-core scaffolding costs more than selective loading can save.
+- **Knowledge a frontier model already applies well** → write no skill at all.
+  Generic guidance adds tokens and steps without adding quality; a no-skill
+  baseline repeatedly tied or beat skills on tasks inside model competence.
+- **Every task needs the entire skill** → it is one document; just ship the
+  bundle, no selective loading to do.

package/assets/skills/meta/ccs-skill-creator/composable/mini/01-create-new-skill.md

@@ -0,0 +1,167 @@
+# Create a New CCS Skill From Scratch
+
+Use this when authoring a brand-new skill (no existing source to convert; for
+that see `02-convert-existing-skill.md`). Follow the steps in order. Each step
+lists exact commands and an **Acceptance** bar you must clear before moving on.
+
+## Step 0: Decide whether to write a skill at all
+
+Apply the "When NOT to use CCS" test from `00-core`: skip the skill if it would
+carry under ~5k tokens of content (ship a single `SKILL.md` instead), or if a
+frontier model already handles it well (write nothing). For each candidate piece
+of guidance ask: *"would a strong model reliably do this unprompted?"* If yes,
+cut it. What remains (the traps and non-obvious calls) is your skill.
+
+**Acceptance:** you can name at least a few trap-dense, non-inferable pieces of
+knowledge, and tasks that use it vary in which subtopics they need.
+
+## Step 1: Scope the domain
+
+Define one coherent domain a practitioner would recognize ("code review",
+"financial analysis"), broad enough to have several subtopics but narrow enough
+that any single task touches only some of them. Write down, before slicing:
+
+- the **subtopics** a practitioner distinguishes;
+- the **cross-cutting traps** that apply regardless of subtopic (these become
+  `00-core`);
+- a few **representative tasks** spanning narrow (one subtopic) to broad (most
+  subtopics), to sanity-check your slicing.
+
+**Acceptance:** a written list of subtopics, cross-cutting traps, and 3–5
+representative tasks.
+
+## Step 2: Create the directory layout
+
+A CCS skill lives under `skills/<category>/<domain>/composable/` with exactly this shape:
+
+```
+skills/<category>/<domain>/
+└── composable/
+    ├── INDEX.md          # the menu (you author this)
+    ├── mini/
+    │   ├── 00-core.md    # optional always-load cross-cutting mini
+    │   └── NN-topic.md   # the authored modules (source of truth)
+    ├── BUNDLE.md         # generated by hive.py compile — never hand-write
+    └── presets/          # optional, generated named subsets
+        └── <name>.md
+```
+
+Pick `<category>` by provenance: `authored/` for a skill written directly in CCS
+form, `converted/` for one ported from an existing upstream skill, `meta/` for a
+skill about the CCS framework itself. Create
+`skills/<category>/<domain>/composable/mini/`. Name minis `NN-topic.md` with a
+two-digit ordinal; the ordinal fixes index and bundle order. `00-core.md` MUST
+use ordinal `00`.
+
+**Acceptance:** `mini/` exists; planned filenames chosen.
+
+## Step 3: Slice the minis (one subtopic each)
+
+Aim for roughly 6–12 minis. Rules:
+
+- **One focused subtopic per mini.** If a mini covers two things a task might
+  want separately, split it. If two minis are never useful apart, merge them.
+- **Order for loading.** Put the "start here" method mini first; group related
+  subtopics adjacently.
+
+**Acceptance:** for each representative task from Step 1, you can list which minis
+it should load. If a needed rule falls cleanly into no single mini, re-slice.
+
+## Step 4: Write each mini, self-contained and uncompressed
+
+Every mini MUST be applicable from *its own text plus `00-core`*, never
+"as covered in the performance mini…". Restate the little that is needed; this
+deliberate redundancy is what makes selective loading safe. Each mini MUST start
+with an H1 (`# Title`). Size follows content: typical minis run ~300–700 words,
+longer when the subtopic demands it. **Never thin content to hit a size**: you
+save tokens by *selection*, never by summarizing.
+
+**Acceptance:** every mini has an H1 and reads correctly with only itself +
+`00-core` in context.
+
+## Step 5: Write `00-core.md` (traps only, if warranted)
+
+`00-core` carries *only* cross-cutting traps: guidance relevant more often than
+a task-scoped reader would guess (data-quality/input-validation discipline,
+"prove it before you claim it", "present ranges not points"). Keep it small. It
+is paid on every load, like the index. It states the cross-cutting rule and
+points to the focused mini for depth; it MUST NOT reproduce a subtopic's full
+treatment. If the skill has no genuinely cross-cutting traps, omit `00-core` and
+instead mark the "start here" method mini always-load in the index.
+
+**Acceptance:** `00-core` (if present) is small and holds only cross-cutting
+material, not a subtopic's depth.
+
+## Step 6: Write the INDEX (a knowledge-free menu)
+
+`INDEX.md` is a menu, not a meal (iron rule 1). Under ~200 words. Structure:
+
+1. An H1 title.
+2. The standard loading-policy header (see below), verbatim, right after the H1.
+3. Exactly **one line per mini**, each carrying (a) the mini filename, (b) a
+   terse content descriptor (the nouns a task matches on), and (c) a **"load
+   when"** hint phrased as an *observable task condition*, not a topic
+   restatement.
+
+If `00-core.md` exists, its line MUST be marked **always load** and the header
+tells the reader to load it first.
+
+Standard header (paste verbatim after the H1):
+
+```
+Loading policy: read this menu, then load 00-core (if present) plus the minis relevant to your task. If you judge most of this skill relevant, load BUNDLE.md (or a matching presets/*.md) in one read instead.
+```
+
+Good line: `` - `04-concurrency.md` — Races, shared state, deadlocks, async,
+TOCTOU. Load when code is threaded, async, or shares state.``. Weak (avoid):
+`` - `04-concurrency.md` — About concurrency.`` (no trigger).
+
+**Acceptance:** one index line per mini and one mini per index line (no drift);
+no line carries knowledge; `00-core` marked always-load if present.
+
+## Step 7: Compile and lint, then fix findings
+
+Generate the bundle (and any presets) and check the structure. Run from the repo
+root:
+
+```bash
+python3 tools/hive.py compile skills/<category>/<domain>
+python3 tools/hive.py lint    skills/<category>/<domain>
+```
+
+`compile` writes `BUNDLE.md`: the deterministic concatenation of every mini in
+ordinal order, `00-core` first, each preceded by a `<!-- module: NN-name.md -->`
+marker. Never hand-edit `BUNDLE.md`. Add a preset only for a real recurring
+configuration: `--presets security-audit=00-core,02 quick=00-core,01`. Do not
+generate a combinatorial family of presets speculatively.
+
+`lint` checks: INDEX exists and references each mini exactly once; index word
+budget; no index line reads like knowledge; `00-core` marked always-load; every
+mini nonempty with an H1; frontmatter (if any) valid; `BUNDLE.md` not stale. Fix
+every **FAIL**; resolve **WARN**s or justify them. Re-run `compile` after any
+mini edit so `BUNDLE.md` is never stale.
+
+**Acceptance:** `lint` exits 0 (`… 0 fail`).
+
+## Worked micro-example: a `sql-migrations` skill
+
+1. **Scope.** Domain = writing safe database schema migrations. Subtopics:
+   backward-compatible changes, destructive changes, index/lock behavior,
+   data backfills. Cross-cutting trap: "a migration runs against production data
+   under live traffic, never assume an empty table or a maintenance window."
+2. **Slice.** Four minis: `01-backward-compatible.md`,
+   `02-destructive-changes.md`, `03-locks-and-indexes.md`, `04-backfills.md`,
+   plus `00-core.md` for the live-traffic trap.
+3. **Minis.** `03-locks-and-indexes.md` restates the "add index concurrently to
+   avoid a table lock" rule even though `01` mentions locks in passing, because
+   a task that loads only `03` must not miss it (self-containment).
+4. **Core.** `00-core.md` (~120 words): live-traffic assumption, "expand then
+   contract" pattern, always ship a tested rollback; points to `02` for the
+   destructive-change detail. Marked always-load.
+5. **Index.** Five lines. `` - `03-locks-and-indexes.md` — CONCURRENTLY, lock
+   modes, long-held locks. Load when adding/dropping indexes or altering large
+   tables.``
+6. **Compile & lint.** `python3 tools/hive.py compile skills/sql-migrations`
+   then `lint` → 0 fail. Narrow task "add a nullable column" loads {00-core, 01}
+   (k/N = 0.4 < 0.6, load minis). Broad "review this whole migration set" →
+   k/N ≥ 0.6 → load `BUNDLE.md` in one read.

package/assets/skills/meta/ccs-skill-creator/composable/mini/02-convert-existing-skill.md

@@ -0,0 +1,120 @@
+# Convert an Existing Skill to CCS
+
+Use this to repackage an existing skill (a monolithic `SKILL.md`, a `SKILL.md`
+plus a `reference/` tree, or a prompt library) into CCS. For a brand-new skill
+with no source, see `01-create-new-skill.md`. The governing rule is iron rule 2:
+**conversion is repackaging, never summarization** (see `00-core`).
+
+## The failure you are avoiding
+
+The `financial-analyst` conversion once decomposed a ~7,000-word source against
+word budgets (250–450 words × ≤11 minis), forcing ~30% compression; token savings
+transferred as predicted but the compressed tail held the judges' deciding
+details and the converted skill *measurably lost quality on both eval tasks*: a
+content loss, not a packaging flaw. That is why the parity gate below is
+mandatory, and why you carry content at **full fidelity with no size caps**.
+
+## Step 1: Inventory the source
+
+Enumerate the source's substantive units: every section/heading, table,
+threshold, worked example, and always-loaded preamble. This list is your parity
+checklist: nothing on it may vanish. Note where the source keeps its knowledge
+(monolith body, reference files, prompt entries) and any always-loaded preamble
+that repeats across files (that repetition is your one legitimate dedup target).
+
+**Acceptance:** a written list of every substantive unit in the source.
+
+## Step 2: Map source structure to CCS elements
+
+| Source structure | Maps to |
+|---|---|
+| Monolith top matter / always-loaded preamble | `00-core` (cross-cutting only) + INDEX framing |
+| Monolith section / heading | one mini (`NN-topic.md`) |
+| `SKILL.md` router / purpose table | `INDEX.md` (add a "load when" hint per entry) |
+| `SKILL.md` always-loaded body | split: cross-cutting → `00-core`; subtopic prose → its mini |
+| `reference/<topic>.md` file | one or more minis (split if coarse) |
+| Prompt-library entry / template | one mini per coherent procedure |
+| Repeated preamble across references | factored once into `00-core` (dedup) |
+| Scripts, fixtures, templates, data | left as-is; referenced from a mini by path |
+| The whole source, recompiled | `BUNDLE.md` (the parity target) |
+
+Two rules of thumb: a coarse reference file (say 2,500 tokens) usually becomes
+**several** minis: one mini reproduces the lost-in-the-middle problem inside a
+single file. And the source's purpose table becomes the INDEX, but you must
+**add** the "load when" hints if the source lacked them; triggers drive expert
+selection.
+
+**Acceptance:** every inventory unit from Step 1 is assigned to a specific mini.
+
+## Step 3: Create the layout and carry content at full fidelity
+
+Create `skills/<category>/<domain>/composable/mini/` (layout identical to a from-scratch
+skill: `INDEX.md`, `mini/00-core.md` + `mini/NN-topic.md`, generated `BUNDLE.md`,
+optional `presets/`). Copy each source unit into its assigned mini **verbatim or
+verbatim-equivalent**. Split coarse references into focused minis (e.g. a DCF
+reference → `04-dcf-projection.md` + `05-terminal-value-sensitivity.md`). Factor
+preamble repeated across three or more source files once into `00-core`. Make
+each mini self-contained (applicable from its own text + `00-core`) and give it
+an H1.
+
+**There are no size caps.** If faithful fidelity needs more room, add minis or
+enlarge them: the fix for "too much content" is *more or larger minis*, never
+tighter prose. Do not compress "to tidy up." Leave scripts/assets untouched and
+reference them from a mini by path.
+
+**Acceptance:** every mini has an H1; every inventory unit is present at full
+fidelity in some mini; only genuine cross-file duplication was removed (and now
+lives once in `00-core`).
+
+## Step 4: Write the INDEX
+
+Turn the source's purpose table into `INDEX.md`: an H1, the standard
+loading-policy header verbatim after it, then one knowledge-free line per mini
+with a filename, terse descriptor, and a **"load when"** observable-condition
+hint. Mark `00-core` **always load** if present. Keep under ~200 words (~300 if
+more than 12 minis). Standard header, pasted verbatim after the H1:
+
+```
+Loading policy: read this menu, then load 00-core (if present) plus the minis relevant to your task. If you judge most of this skill relevant, load BUNDLE.md (or a matching presets/*.md) in one read instead.
+```
+
+## Step 5: Compile, then run the parity gate and lint
+
+Run from the repo root:
+
+```bash
+python3 tools/hive.py compile skills/<category>/<domain>
+python3 tools/hive.py parity  skills/<category>/<domain> <source-dir>
+python3 tools/hive.py lint    skills/<category>/<domain>
+```
+
+`parity` compares the union of your minis against the original source. It reports
+a **token ratio** (mini tokens ÷ source tokens) and lists any source `##`/`###`
+heading with no fuzzy match in the minis (possibly dropped). Acceptance bar:
+
+- Ratio **≥ 85%** is the hard floor (below it, `parity` FAILs and summarization
+  is suspected). **Aim for 95%+**: a faithful conversion loses tokens only to
+  genuine dedup, so the union of minis should be nearly the whole source.
+- The dropped-heading list must be **empty**, or every entry on it explained as
+  genuine duplication now living once in `00-core`. Treat each listed heading as
+  a real gap: open the source section, find where it should live, and restore it
+  into the right mini. Re-run `compile` then `parity` until clean.
+
+`lint` must exit 0 (INDEX/mini/core structural rules, `00-core` marked
+always-load, `BUNDLE.md` not stale). A conversion that cannot pass parity within
+your current mini count needs **more or larger minis, not tighter prose**.
+
+**Acceptance:** `parity` ratio ≥ 85% (target 95%+) with no unexplained dropped
+heading, **and** `lint` exits 0. Only then is the conversion done.
+
+## Edge cases
+
+- **No cross-cutting content in the source** → omit `00-core`; mark the "start
+  here" mini always-load instead. Don't invent core material.
+- **Script-heavy skill** → convert only the knowledge markdown; leave
+  `scripts/`, `assets/`, fixtures exactly as they are and reference them by path.
+- **Source already close to CCS** (fine-grained references with triggers) →
+  conversion is mostly mechanical: rename to `NN-topic.md`, write the INDEX with
+  "load when" hints, compile, parity-check. Still do not compress.
+- **Very large source** that overflows your intended mini count at full
+  fidelity → raise the mini count. Parity outranks any target mini count.

package/assets/skills/meta/ccs-skill-creator/composable/mini/03-review-and-maintain.md

@@ -0,0 +1,112 @@
+# Review and Maintain a CCS Skill
+
+Use this when changing a skill that already exists in CCS format: editing its
+knowledge, adding a preset, or checking it still conforms. The governing
+discipline is the source/artifact split: `mini/*.md` is the only source of
+truth; `INDEX.md`, `BUNDLE.md`, and `presets/*.md` are derived.
+
+## The maintenance loop (edit minis, recompile, relint)
+
+To change any knowledge:
+
+1. **Edit the mini**, never `BUNDLE.md` or `presets/*.md`. Those are generated;
+   hand-edits are overwritten on the next compile and break the parity guarantee.
+2. **Recompile** so the bundle (and presets) match the minis again:
+
+   ```bash
+   python3 tools/hive.py compile skills/<category>/<domain>
+   ```
+
+3. **Relint** and fix every FAIL:
+
+   ```bash
+   python3 tools/hive.py lint skills/<category>/<domain>
+   ```
+
+   `lint` flags a **stale BUNDLE.md** (`does not match mini/*.md — re-run
+   compile`) whenever a mini changed but the bundle was not regenerated. Note the
+   asymmetry: editing only `INDEX.md` does *not* stale the bundle (the bundle is
+   built from minis, not the index), but it can still break other lint rules
+   (drift, word budget, always-load marking), so relint after any edit.
+
+**Acceptance:** `lint` exits 0 after every change.
+
+## Keep the INDEX in sync
+
+Every mini file MUST have exactly one index line, and every index line exactly
+one mini file: `lint` fails on drift. So:
+
+- **Add a mini** → add its one knowledge-free index line (descriptor + "load
+  when" hint), keep it under the word budget, then recompile.
+- **Remove a mini** → delete its file *and* its index line, then recompile.
+- **Rename a mini** → rename the file and update the index line's filename, then
+  recompile (the bundle's `<!-- module: … -->` marker tracks the new name).
+
+Keep edits within the "index is a menu, not a meal" rule: never migrate
+knowledge into the index to "clarify" it. If a mini's trigger is unclear, sharpen
+the "load when" condition, not by adding skill content.
+
+**Acceptance:** one index line per mini and one mini per index line; index still
+under ~200 words (~300 for >12 minis); no line reads like knowledge.
+
+## Editing content without regressing fidelity
+
+When the skill was produced by *conversion*, re-run the parity gate after
+substantive edits so you don't silently drop content:
+
+```bash
+python3 tools/hive.py parity skills/<category>/<domain> <source-dir>
+```
+
+Keep the ratio ≥ 85% (aim 95%+) with no unexplained dropped heading. When adding
+new original knowledge (no external source), there is nothing to parity against:
+just ensure the new mini is self-contained and the bundle recompiles clean.
+
+## Adding presets, especially for variant-split skills
+
+A **preset** is a named compiled subset of minis for a recurring configuration,
+built by the same concatenation rules as the bundle. Generate presets with the
+`--presets NAME=IDS` flag on `compile` (ids may be ordinals like `01`, stems, or
+filenames; comma-separated; order preserved):
+
+```bash
+python3 tools/hive.py compile skills/<category>/<domain> \
+  --presets security-audit=00-core,02 python-server=00-core,01,02,11,12
+```
+
+This writes `presets/security-audit.md` and `presets/python-server.md`. Presets
+SHOULD be few and named for real recurring tasks. Do not generate a
+combinatorial family speculatively.
+
+**The variant-split case is where presets earn their keep.** When a skill
+contains mutually-exclusive tracks, such as language variants (Python *vs* Node)
+or platform variants (iOS *vs* Android), a broad task should never load the whole
+bundle, because half of it is irrelevant to the chosen variant. Ship one preset
+per variant: each is `00-core` + the shared minis + only that variant's minis, so
+a "build the whole Python server" task loads `presets/python-server.md` in one
+read with zero cross-variant waste. Reference these presets in the INDEX's
+loading header or a note so the loader knows to prefer them for broad
+variant-specific work.
+
+**Acceptance:** each preset covers exactly one real recurring configuration;
+`presets/*.md` are tool-generated (never hand-edited); `lint` exits 0.
+
+## Conformance re-check
+
+Before considering maintenance done, confirm the skill still satisfies the spec:
+knowledge-free INDEX under budget with one "load when" line per mini; focused,
+self-contained, uncompressed minis each with an H1; a small `00-core` where
+warranted, marked always-load; a tool-generated, boundary-marked, never-
+hand-edited `BUNDLE.md` and any presets; passing parity (for converted skills);
+untouched non-knowledge assets. A single command reports lint status across every
+skill in the repo:
+
+```bash
+python3 tools/hive.py report skills
+```
+
+`report` prints a per-skill token/size table with a `lint (P/W/F)` column and
+exits nonzero if any skill has a lint FAIL. Use it as the final green light.
+
+**Acceptance:** `report skills` shows the maintained skill with `0F` (zero
+fails).

package/assets/skills/sources/anthropic/PROVENANCE.md

@@ -0,0 +1,3 @@
+Source: https://github.com/anthropics/skills (skills/mcp-builder, skills/internal-comms),
+vendored unmodified for CCS packaging research and benchmarking. See upstream
+repository for license terms; these copies retain all original content.

package/assets/skills/sources/anthropic/claude-api/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Anthropic, PBC.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.