stackfit 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.1.1
+
+- Git exclude now lists only the files stackfit generates (plus `.agents/` and the two skill links) in one managed block. Earlier versions excluded the whole `.claude/` and `.cursor/` folders, which hid a user's own files there (for example `.claude/settings.json`) from git. The next sync replaces the old lines; your own lines in `.git/info/exclude` are kept.
+- New: `skills/stackfit`, an agent skill that teaches Claude Code, Cursor, and Codex how to use stackfit (`npx skills add amin0075/stackfit`).
+
+## 0.1.0
+
+- First release.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Amin Keshavarzi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,186 @@
-# Temporary Holding Version
+# stackfit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Your agent loads every skill in every repo. It needs a handful.**
+
+stackfit keeps one catalog of agent skills, rules, commands, and subagents, and gives each repository only what fits its stack: Next.js skills where there is `next`, Stripe skills where there is `stripe`, nothing for design in a Go service. It renders them for **Claude Code, Cursor, and Codex**, across every project on your machine, in one command.
+
+![stackfit demo](https://raw.githubusercontent.com/amin0075/stackfit/main/media/demo.gif)
+
+```bash
+npx stackfit catalog init --starter   # a catalog in ~/.stackfit with curated packs
+npx stackfit refresh --all            # vendor the upstream skills (Vercel, shadcn, Stripe, ...)
+npx stackfit report --root ~/code     # what each repo would load, next to what your global skills cost today
+npx stackfit sync --root ~/code       # write it
+```
+
+### Or let your agent do it
+
+stackfit ships an agent skill that knows every command, recipe, and error message:
+
+```bash
+npx skills add amin0075/stackfit      # or copy skills/stackfit into ~/.claude/skills
+```
+
+Then ask your agent: *"Set up stackfit for my repos in ~/code and tell me honestly what it saves."* It measures your current global skills first, previews before writing, and never forces over your own files. The starter catalog includes the same skill.
+
+## Why
+
+Every installed skill puts its name and description into every agent session, so the agent knows it exists. Install 40 skills globally and a Go service pays for your React animation guides on every turn. Copy skills into each repo by hand and they drift, go stale, and lose your edits on the next update.
+
+stackfit treats agent context like a dependency:
+
+- **Packs, detected per repo.** Skills belong to packs. A pack is selected when the repo's manifests mention a dependency or contain a file: `package.json`, `requirements.txt`, `pyproject.toml`, `go.mod`, `Cargo.toml`, `composer.json`, at the root and in subfolders like `web/`, `apps/*`, `packages/*`.
+- **One catalog, every repo.** Machine profiles list your project folders on each computer (Mac at home, Windows at work). `stackfit update --all` pulls the catalog and syncs them all.
+- **Measured, honestly.** `stackfit report` shows what each repo loads every session (skill listings + always-on rules) next to what your global skill folders already cost everywhere; `stackfit audit` flags stale, unsourced, and oversized skills.
+- **Upstream skills without losing your edits.** Vendor skills from GitHub with `refresh`; shorten a description, make a skill manual-only, or drop files with `render` overrides that survive every refresh.
+- **Native for each agent.** Claude Code gets `.claude/skills`, `.claude/rules` (glob rules become `paths:`), manual-only commands, and subagents. Cursor gets `.cursor/skills`, `.mdc` rules, commands, and agents. Codex reads `.agents/skills`. One physical copy, symlinked (junctions on Windows, no admin needed).
+- **Safe.** Generated files are tracked in a lock and only those exact files are excluded from Git locally (your own `.claude/settings.json` stays visible). stackfit never overwrites a file it did not create, and never touches files your repo owns.
+
+## Example
+
+The starter catalog, four sample repos, and 31 skills installed globally the usual way:
+
+```text
+$ stackfit report --root ~/code
+project         skills  skill listings     rules  per session  packs
+ingest-worker        2        ~168 tok   ~83 tok     ~251 tok  core
+marketing-site      25       ~1.5k tok   ~83 tok    ~1.6k tok  core, react, nextjs, ui, motion
+payments-api         5        ~397 tok   ~83 tok     ~480 tok  core, stripe
+storefront          24       ~1.5k tok   ~83 tok    ~1.6k tok  core, react, nextjs, e2e, ui, shadcn, stripe
+
+With stackfit: ~4.0k tokens across 4 project(s). Every catalog skill in every repo would be ~8.7k.
+Global skills add ~3.0k tokens to every session in every repo, with or without stackfit: ~/.claude/skills (31).
+```
+
+Read it honestly: the saving comes from moving skills out of global folders and letting each repo take only its packs. The Go worker drops from ~3.0k to ~251 tokens; a Next.js app that needs most packs saves little. If you only had a handful of global skills, start from an empty catalog with just those (`stackfit catalog init`) rather than the starter, or the starter's extra packs can add context instead of removing it. `report` always shows both numbers, so you can tell.
+
+## How it works
+
+```text
+~/.stackfit/                        your catalog (keep it in a private Git repo)
+  stackfit.json                     enabled skills + packs
+  skill-sources.json                where each skill comes from, review dates, render overrides
+  skills/<name>/SKILL.md            the skills
+  rules/  commands/  agents/        shared adapters
+  stackfit.local.json               (gitignored) your project folders per machine
+  .env                              (gitignored) values for {{env:NAME}} placeholders
+
+<project>/
+  .agents/skills/                   the selected skills (one physical copy)
+  .claude/skills  .cursor/skills    symlinks to it
+  .claude/rules/*.md  .cursor/rules/*.mdc
+  .claude/commands  .cursor/commands
+  .claude/agents  .cursor/agents
+  .stackfit.lock.json               what stackfit owns here
+  docs/agent/config.json            (optional, tracked) this repo's pack choices
+```
+
+### Packs
+
+```json
+{
+  "schemaVersion": 3,
+  "skills": ["grilling", "next-server-security", "next-dev-loop", "shadcn"],
+  "packs": {
+    "core":   { "always": true, "skills": ["grilling"] },
+    "nextjs": { "detect": { "dependencies": ["next"] }, "skills": ["next-server-security", "next-dev-loop"] },
+    "shadcn": { "detect": { "files": ["components.json"] }, "skills": ["shadcn"] },
+    "python": { "detect": { "dependencies": ["django", "fastapi"] }, "skills": [] }
+  }
+}
+```
+
+`always` packs go everywhere; `detect` packs are chosen automatically; packs with neither are opt-in. A repository adjusts its own selection in `docs/agent/config.json`:
+
+```json
+{ "schemaVersion": 1, "packs": ["motion"], "excludePacks": ["stripe"], "skills": ["ui-ux-pro-max"] }
+```
+
+Or, without touching the repo, on its entry in `stackfit.local.json`.
+
+### Machines
+
+```json
+{
+  "schemaVersion": 1,
+  "machines": [
+    { "id": "mac", "match": { "platform": "darwin" }, "roots": ["~/code"], "projects": ["storefront", { "name": "client-site", "scaffold": false, "packs": ["motion"] }] },
+    { "id": "work", "match": { "platform": "win32", "hostname": "WORK-PC" }, "roots": ["C:/dev"] }
+  ]
+}
+```
+
+Then `stackfit sync --all` on each machine. Without `projects`, every Git repo under `roots` is synced.
+
+### Upstream skills and overrides
+
+```json
+"shadcn": {
+  "kind": "external",
+  "source": { "repository": "https://github.com/shadcn-ui/ui.git", "path": "skills/shadcn" },
+  "reviewed": "2026-10-26",
+  "render": {
+    "frontmatter": { "description": "Add, search, and style shadcn/ui components. Use with components.json." },
+    "exclude": ["evals/evals.json"]
+  }
+}
+```
+
+`stackfit refresh --skill shadcn` replaces the vendored copy and records the upstream commit in `skill-sources.lock.json`. Your `render` overrides apply at sync time, so they survive. Set `"disable-model-invocation": true` on long one-off workflows (migrations, adoptions) so they cost nothing until you call them.
+
+### Personal values
+
+Commands, rules, and agents can contain `{{env:NAME}}`. stackfit fills them at sync time from your shell or the catalog's gitignored `.env`, so a shared catalog never holds handles, emails, or tokens. See `.env.example`.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `stackfit catalog init [dir] [--starter]` | Create a catalog (default `~/.stackfit`) |
+| `stackfit report` | Per project: packs, skills, skill-listing and rule tokens; plus your global skill folders as a baseline (`--json`) |
+| `stackfit status` | Dry run of sync; `--check` exits 1 on drift (CI) |
+| `stackfit sync` | Render the selected skills, rules, commands, and agents |
+| `stackfit update` | `git pull --ff-only` the catalog, then sync |
+| `stackfit init` | Add tracked `AGENTS.md`, `CLAUDE.md`, and `docs/agent/` to projects; never overwrites |
+| `stackfit refresh --skill <name> \| --all` | Vendor upstream skills into the catalog |
+| `stackfit audit` | Check provenance, staleness (180 days), packs, description sizes |
+
+Select projects with `--project <path>`, `--root <dir>[,<dir>]`, or `--all` (this machine's profile). The catalog is found from `--catalog`, `STACKFIT_CATALOG`, the nearest `stackfit.json` above the current folder, or `~/.stackfit`.
+
+## The starter catalog
+
+`--starter` gives you packs built from maintained upstream skills, plus two first-party ones:
+
+| Pack | Selected by | Skills |
+| --- | --- | --- |
+| core | always | grilling (Matt Pocock), improve (shadcn) |
+| react | `react` | vercel-react-best-practices, vercel-composition-patterns, react-doctor |
+| nextjs | `next` | next-server-security, next-dev-loop, next-bundle-optimizer, Cache Components and Partial Prefetching workflows (manual-only), vercel-react-view-transitions (manual-only) |
+| e2e | `@playwright/test` | playwright-e2e-testing |
+| ui | `react-dom`, `vue`, `svelte`, `tailwindcss`, ... | frontend-design (Anthropic), interface-design, baseline-ui, fixing-accessibility, make-interfaces-feel-better, web-design-guidelines |
+| shadcn | `components.json` | shadcn |
+| motion | `motion`, `framer-motion`, `gsap`, ... | Emil Kowalski's animation skills, fixing-motion-performance |
+| stripe | `stripe`, `@stripe/*` | stripe-best-practices, upgrade-stripe, stripe-projects |
+| design-research | opt-in | ui-ux-pro-max |
+
+Skills are vendored from their authors' repositories under their own licences when you run `refresh`; stackfit does not redistribute them.
+
+Next.js 16.2+ ships version-matched docs in `node_modules/next/dist/docs`, and `next dev` adds a managed block to `AGENTS.md` pointing agents at them. That is why the starter has no generic "Next.js best practices" skill: workflows belong in skills, framework reference belongs in the bundled docs.
+
+## FAQ
+
+**Does it replace `npx skills` / skills.sh?** No. Those install skills. stackfit decides which repo gets which, keeps them in sync across many repos and agents, and measures the cost. Point `skill-sources.json` at any GitHub skill.
+
+**What about my existing `.cursor/rules` or `.claude/skills`?** stackfit refuses to overwrite files it does not own. Move your own files into the catalog (shared) or `docs/agent/` (repo-specific), or pass `--force` once you have reviewed the collision.
+
+**Does it commit anything to my projects?** No. Generated paths are added to `.git/info/exclude`. Only `stackfit init` creates tracked files (`AGENTS.md`, `CLAUDE.md`, `docs/agent/`), and only when you run it.
+
+**Windows?** Yes. Skill folders are linked with directory junctions, which need no admin rights or developer mode.
+
+## Contributing
+
+Issues and PRs welcome, especially new detection signals and agent targets. See [CONTRIBUTING.md](CONTRIBUTING.md). Run `npm test` (Node 22+, no dependencies).
+
+## License
+
+MIT © Amin Keshavarzi

package/bin/stackfit.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadRegistry, resolveCatalog } from "../src/catalog.mjs";
+import { auditCatalog, printAudit } from "../src/audit.mjs";
+import { selectedProjects } from "../src/projects.mjs";
+import { refreshSkills } from "../src/refresh.mjs";
+import { globalSkills, printReport, projectReport, skillCosts } from "../src/report.mjs";
+import { initCatalog, initProject } from "../src/scaffold.mjs";
+import { applyPlan, createPlan, git } from "../src/sync.mjs";
+
+const VERSION = JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../package.json"), "utf8")).version;
+
+const HELP = `stackfit ${VERSION}: give each repo only the agent skills that fit its stack.
+
+Usage: stackfit <command> [options]
+
+Commands:
+  catalog init [dir]    Create a catalog (default ~/.stackfit); --starter adds curated packs
+  report                Per project: packs, skills, always-loaded tokens; plus global skills
+  status                Dry run of sync; --check exits 1 when anything would change (CI)
+  sync                  Render the selected skills, rules, commands, and agents into projects
+  update                git pull --ff-only the catalog, then sync
+  init                  Add tracked docs/agent scaffolding to projects; never overwrites
+  refresh               Vendor upstream skills into the catalog (--skill <name> | --all)
+  audit                 Check the catalog: provenance, staleness, packs, context cost
+
+Project selection:
+  --project <path>      One repository
+  --all                 This machine's projects from stackfit.local.json
+  --root <dir>[,<dir>]  Every Git repository directly under these folders
+
+Options:
+  --catalog <dir>       Catalog folder (else STACKFIT_CATALOG, the nearest stackfit.json, ~/.stackfit)
+  --dry-run             Report without writing
+  --force               Take ownership of colliding unmanaged files
+  --quiet               Summaries only
+  --json                Machine-readable output (report, audit)
+  --skip-pull           update without git pull
+  --version, --help
+
+Docs: https://github.com/amin0075/stackfit`;
+
+function parseArgs(argv) {
+  const options = { positional: [] };
+  const flags = { "--all": "all", "--force": "force", "--dry-run": "dryRun", "--quiet": "quiet", "--skip-pull": "skipPull", "--check": "check", "--json": "json", "--starter": "starter", "--help": "help", "-h": "help", "--version": "version", "-v": "version" };
+  const values = { "--project": "project", "--root": "root", "--skill": "skill", "--catalog": "catalog" };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (flags[arg]) options[flags[arg]] = true;
+    else if (values[arg]) {
+      if (argv[index + 1] === undefined) throw new Error(`${arg} needs a value`);
+      options[values[arg]] = argv[++index];
+    } else if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+    else options.positional.push(arg);
+  }
+  [options.command, ...options.args] = options.positional;
+  return options;
+}
+
+async function run(options) {
+  if (options.version) return console.log(VERSION);
+  if (options.help || !options.command) return console.log(HELP);
+  const { command } = options;
+
+  if (command === "catalog") {
+    if (options.args[0] !== "init") throw new Error("Usage: stackfit catalog init [dir] [--starter]");
+    return initCatalog(options.args[1], options);
+  }
+
+  const catalog = resolveCatalog(options.catalog);
+  if (command === "audit") {
+    const result = auditCatalog(catalog);
+    if (options.json) console.log(JSON.stringify(result, null, 2));
+    else printAudit(result);
+    if (result.errors.length) process.exitCode = 1;
+    return;
+  }
+  if (command === "refresh") return refreshSkills(catalog, options);
+  if (!["status", "sync", "update", "init", "report"].includes(command)) throw new Error(`Unknown command '${command}'. Run stackfit --help.`);
+
+  if (command === "update" && !options.skipPull) {
+    if (git(["status", "--porcelain"], catalog.root).stdout.trim()) throw new Error("Catalog has local changes; commit or stash them before update");
+    if (git(["pull", "--ff-only"], catalog.root, "inherit").status !== 0) throw new Error("Could not fast-forward the catalog");
+  }
+  const { projects, machine } = selectedProjects(catalog, options);
+  if (machine && !options.quiet && !options.json) console.log(`machine: ${machine.id} (${machine.platform}, ${machine.hostname})`);
+
+  if (command === "init") {
+    let total = 0;
+    for (const project of projects) total += await initProject(project.path, { ...options, scaffold: project.scaffold });
+    return console.log(`${options.dryRun ? "Would create" : "Created"} ${total} tracked docs file(s) across ${projects.length} project(s).`);
+  }
+
+  const registry = loadRegistry(catalog);
+  if (command === "report") {
+    const costs = skillCosts(catalog, registry);
+    const result = { projects: [], global: globalSkills() };
+    for (const project of projects) result.projects.push(await projectReport(catalog, registry, project, costs));
+    return options.json ? console.log(JSON.stringify(result, null, 2)) : printReport(result);
+  }
+
+  if (command === "status") options.dryRun = true;
+  let total = 0;
+  for (const project of projects) {
+    const plan = await createPlan(catalog, project.path, registry, { scaffold: project.scaffold, selection: project.selection });
+    const actions = await applyPlan(catalog, project.path, plan, options);
+    total += actions.length;
+    const suffix = project.scaffold ? "" : " [adapter-only]";
+    console.log(`${plan.projectName}: ${actions.length ? `${actions.length} change(s)` : "up to date"}${suffix}`);
+    if (!options.quiet) {
+      console.log(`  packs: ${plan.packs.join(", ")}`);
+      for (const action of actions) console.log(`  ${action.type.padEnd(6)} ${action.key}`);
+    }
+  }
+  console.log(`${options.dryRun ? "Would apply" : "Applied"} ${total} generated change(s) across ${projects.length} project(s).`);
+  if (options.check && total) process.exitCode = 1;
+}
+
+run(parseArgs(process.argv.slice(2))).catch((error) => {
+  console.error(`stackfit: ${error.message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "stackfit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Give each repo only the AI agent skills that fit its stack. One catalog, every project, Claude Code + Cursor + Codex.",
+  "type": "module",
+  "bin": {
+    "stackfit": "./bin/stackfit.mjs"
+  },
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "bin",
+    "schemas",
+    "src",
+    "starter"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "test": "node --test test/stackfit.test.mjs",
+    "check": "node --check bin/stackfit.mjs && node --test test/stackfit.test.mjs"
+  },
+  "keywords": [
+    "agent-skills",
+    "claude-code",
+    "cursor",
+    "codex",
+    "agents-md",
+    "skills",
+    "ai-agents",
+    "context",
+    "monorepo",
+    "nextjs"
+  ],
+  "author": "Amin Keshavarzi (https://github.com/amin0075)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/amin0075/stackfit.git"
+  },
+  "homepage": "https://github.com/amin0075/stackfit#readme",
+  "bugs": "https://github.com/amin0075/stackfit/issues"
+}

package/schemas/project-config.schema.json

@@ -0,0 +1,71 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "stackfit project config (docs/agent/config.json)",
+  "type": "object",
+  "required": [
+    "schemaVersion"
+  ],
+  "properties": {
+    "schemaVersion": {
+      "const": 1
+    },
+    "packs": {
+      "$ref": "#/$defs/componentNames",
+      "description": "Packs to include in addition to auto-detected ones (e.g. \"motion\" for CSS-only animation work, \"design-research\")."
+    },
+    "excludePacks": {
+      "$ref": "#/$defs/componentNames",
+      "description": "Auto-detected packs to skip. `core` cannot be excluded."
+    },
+    "detect": {
+      "type": "boolean",
+      "default": true,
+      "description": "Set false to use only `core` plus the packs listed explicitly."
+    },
+    "skills": {
+      "$ref": "#/$defs/componentNames",
+      "description": "Individual catalog skills to add without taking their whole pack."
+    },
+    "disabledSharedSkills": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "uniqueItems": true,
+      "description": "Rare opt-out for a shared skill that is misleading in this repository. Applied last."
+    },
+    "overrides": {
+      "type": "object",
+      "description": "Explicit names of repo-owned components allowed to replace shared components.",
+      "properties": {
+        "skills": {
+          "$ref": "#/$defs/componentNames"
+        },
+        "agents": {
+          "$ref": "#/$defs/componentNames"
+        },
+        "commands": {
+          "$ref": "#/$defs/componentNames"
+        },
+        "rules": {
+          "$ref": "#/$defs/componentNames"
+        }
+      },
+      "additionalProperties": false
+    },
+    "$schema": {
+      "type": "string"
+    }
+  },
+  "$defs": {
+    "componentNames": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      },
+      "uniqueItems": true
+    }
+  },
+  "additionalProperties": false
+}

package/schemas/skill-sources.schema.json

@@ -0,0 +1,97 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "stackfit skill provenance (skill-sources.json)",
+  "type": "object",
+  "required": [
+    "schemaVersion",
+    "skills"
+  ],
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "$comment": {
+      "type": "string"
+    },
+    "schemaVersion": {
+      "const": 2
+    },
+    "skills": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "required": [
+          "kind"
+        ],
+        "properties": {
+          "kind": {
+            "enum": [
+              "external",
+              "custom"
+            ],
+            "description": "external: vendored from upstream and refreshable. custom: owned in this catalog."
+          },
+          "source": {
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "type": "object",
+                "required": [
+                  "repository",
+                  "path"
+                ],
+                "properties": {
+                  "repository": {
+                    "type": "string"
+                  },
+                  "path": {
+                    "type": "string"
+                  }
+                },
+                "additionalProperties": false
+              }
+            ]
+          },
+          "reviewed": {
+            "type": "string",
+            "format": "date",
+            "description": "Last date a human checked the skill is current and worth its context. audit warns after 180 days."
+          },
+          "note": {
+            "type": "string"
+          },
+          "render": {
+            "type": "object",
+            "description": "Sync-time overrides that survive refreshes.",
+            "properties": {
+              "frontmatter": {
+                "type": "object",
+                "description": "SKILL.md frontmatter keys to replace (null removes a key).",
+                "additionalProperties": {
+                  "type": [
+                    "string",
+                    "boolean",
+                    "number",
+                    "null"
+                  ]
+                }
+              },
+              "exclude": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                },
+                "description": "Skill-relative files not synced into projects."
+              }
+            },
+            "additionalProperties": false
+          }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}