Skip to main content
skill CX Codex

framework — Claude Code skill: project manifest and lifecycle

framework — a skill for Claude Code, Cursor, and other platforms that tracks every installed file and coordinates project setup, recovery, diagnostics, and cleanup through a single manifest.

MIT ★ 571 updated 2026-10-29

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add ai-driven-dev/framework --skill framework -a claude-code
Open on GitHub

What framework does

framework owns the installation record and all operations on it: the manifest that tracks every installed file, and the flows that read or change that record — setup, doctor, sync (restore), uninstall, and plugin operations. It runs on Claude Code, Cursor, Codex, GitHub Copilot, and OpenCode.

The context holds domain models for the manifest and its components, plugin state, diagnostic shape, and entry points for top-level operations. framework is the only context permitted to reach all others: translate, tools, kernel, and distribution. This bridge is necessary because assembling what goes to disk is the job that needs all three.

Before writing any framework file, it checks whether the file exists and is not tracked in the manifest — if so, the write is skipped with a warning, and the file stays user-owned. Global orchestrators iterate over every scope and complete even if one fails; errors are collected in an array and returned in the result, never stopping the run.

What it helps with

  • track all installed files and their state in a single manifest
  • restore project state from the manifest record
  • install and update plugins without overwriting user files
  • diagnose installation issues and verify manifest integrity
  • cleanly remove tools and their traces from the project

Example prompts for the agent

  • Add the framework skill to begin tracking installations in your project
  • Run a diagnosis to check for missing or corrupted files
  • Restore the full project state from the manifest using sync

How to install framework

1Skills CLI (Vercel)

npx skills add ai-driven-dev/framework --skill framework -a claude-code

2Manually: put the files in place

~/.claude/skills/framework/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/framework/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about framework

How do I install framework in Claude Code?

Run npx skills add ai-driven-dev/framework --skill framework -a claude-code, then open ~/.claude/skills/framework/SKILL.md.

What does framework do?

It maintains a manifest of all installed project files and manages setup, restore, diagnose, and uninstall flows. It prevents overwriting files you created manually.

Which platforms support framework?

Claude Code, Cursor, Codex, GitHub Copilot, and OpenCode each have their own install command and skill file location.

Source text

SKILL.md · MIT
---
name: framework
description: >
  Owns the installation record and everything done to a project, under
  src/contexts/framework/ — the manifest aggregate, and the setup/install/restore/uninstall/doctor
  orchestration built on top of it. This is the only context allowed to reach `translate` and
  `distribution`. Use when adding a use-case that touches the manifest, a
  setup/doctor/sync/uninstall flow, a new top-level CLI orchestration, or a launcher that runs an
  external binary (kanban-shaped). Do NOT use for a tool's own profile or capability classes —
  use `tools`. Do NOT use for the translation pipeline — use `translate`. Do NOT use for where
  content is fetched from — use `distribution`.
---

# Framework

`framework` is what is posed on a project and the record of it: the manifest that tracks every
installed file, and every flow that reads or changes that record — setup, doctor, sync (restore),
uninstall, plugin install/update/remove, and the global chain orchestrators. It is the one
context the dependency chain lets reach every other context (`framework →
translate → tools → kernel`, plus `framework → distribution`), because assembling what goes on
disk is exactly the job that needs all three.

## What goes in

| Concept | Location |
|---|---|
| The manifest aggregate and its members | `domain/manifest.ts`, `domain/manifest/` (tool-entry, tracked-files, merge-files, native-registrations) |
| A plugin's declared state | `domain/plugins/` (installed-plugin, source-resolver, requested-version-policy) |
| The diagnosis shape | `domain/doctor.ts` |
| Setup orchestration state | `domain/setup-flow.ts` |
| A port only `framework` needs | `domain/ports/` (manifest-repository, plugin-distribution-reader, user-source-references) |
| A top-level flow's orchestrator | `application/` root, or a feature subdirectory (`clean/`, `doctor/`, `flows/`, `framework/`, `global/`, `install/`, `plugin/`, `restore/`, `setup/`, `uninstall/`) |
| Logic needed by ≥2 top-level use-cases | `application/shared/` — never called from a command |
| The manifest-repository and plugin-distribution-reader adapters | `infrastructure/` |

## How

- A use-case class ends in `UseCase`, has a single `async execute(options): Promise<Result>`,
  never catches its own errors except the three carve-outs (global aggregate-error loops,
  cache/network fallback, typed-throw translation) — see the use-case and orchestration rules in
  `.claude/rules/00-architecture/`.
- A use case that installs framework files saves the manifest and updates `.gitignore`
  through `PostInstallPipelineUseCase`. A use case that only changes the manifest (plugin
  add/remove, marketplace sync, restore) saves it directly. See `references/post-install-pipeline.md`.
- Before writing any framework file: check `fs.fileExists(path) && !manifest.isFileTracked(path)`.
  If both are true, skip the write, warn, and never add it to the manifest — never overwrite a
  user-owned file. See `references/manifest.md`.
- A global chain orchestrator (`*-all-use-case.ts`) iterates every scope and must finish even if
  one fails: wrap one iteration in `try/catch`, push a typed entry to an `errors[]` array, and
  return it in the result — never let one tool's failure abort the whole run.
- A capability-guard sub-use-case (`install-agents-use-case.ts` and its siblings) checks
  `"name" in caps` before dispatching to a narrowed sub-use-case in `install/` — see
  `references/post-install-pipeline.md`, section "Capability sub-use-cases". These five files reach directly into `tools`'
  capability classes rather than through a declared public module; that reach is a tracked,
  shrinking exception in `context-boundary.arch.test.ts`, not a pattern to add to.
- **A launcher spawns its target, never imports it.** The decision and its cost are in
  `aidd_docs/memory/architecture.md`.

## Public surface

Nothing outside `contexts/framework/` may import a module this context has not declared public.
`framework` is also the context most other contexts should never see: nothing in `tools`,
`translate`, or `distribution` may import from `framework` at all — the arrow only runs the other
way. Check `tests/architecture/context-graph.arch.test.ts` before adding an edge; check
`context-boundary.arch.test.ts`'s `PUBLIC_MODULES` before assuming a module framework itself
exposes is reachable from `presentation` or `runtime`.

## How it's tested

- `tests/contexts/framework/` mirrors `src/contexts/framework/` — domain models are unit-tier,
  use-cases against in-memory ports (`tests/helpers/ports/`) are unit or integration depending on
  whether they touch a real temp filesystem.
- `tests/e2e/` exercises full CLI invocations through `runCli()`; `tests/golden/` snapshots a
  built framework tree end to end — see the `test` skill for tier and golden-snapshot rules.
- A manifest version-guard change needs a fixture manifest at the boundary version, asserting the
  exact refusal message names the fix.

© ai-driven-dev · MIT · ai-driven-dev/framework

Similar skills

All skills for Agent setup: memory, context, orchestration →
alibabacloud-emr-starrocks-manage aliyun alibabacloud-emr-starrocks-manage — a skill for Alibaba Cloud EMR Serverless StarRocks lifecycle management: create, scale, configure, and troubleshoot instances via CLI. Use it when SREs or architects need to automate StarRocks operations. CX Codex +1 176installs catalyst-basics catalystbyzoho catalyst-basics — a skill that walks the agent through Zoho Catalyst project setup: directory layout, environments, CLI commands and every project ID. Handy when you need a Table ID or a look at .catalystrc. CX Codex +1 1,200installs om-setup-agent-pipeline open-mercato om-setup-agent-pipeline configures an agent pipeline for a repository and checks which related skills are missing. Run it for an initial setup or after changing the toolchain or label system. CX Codex +1 4,700installs Capability Graph Builder daffy0208 Capability Graph Builder builds a queryable capability graph from tool manifests and checks relationships via Codex. Useful when setting up an orchestration knowledge base. CX Codex +1 130installs Framework Orchestrator daffy0208 The Framework Orchestrator skill maps frameworks and other skills to project phases. Use it when you need a project pattern, an ordered plan, or phase checks. CX Codex +1 136installs huawei-cloud-flexus-l-server-manage huaweicloud The huawei-cloud-flexus-l-server-manage skill manages Huawei Cloud Flexus L instances: it checks available options, creates servers, renews them, and handles subscription cancellation. CX Codex +1 201installs

From the same set80

The whole set →
04-fact-check 04-fact-check verifies factual statements against authoritative sources and rewrites prose with citations, hedging claims that lack proof. Not meant for judging code. CX Codex +1 ★ 571repo stars distribution distribution — a skill for Claude Code, Cursor, Codex, GitHub Copilot and OpenCode that manages where plugin and marketplace content comes from and how to fetch it. CX Codex +1 ★ 571repo stars translate Turns the framework's canonical source into native content for each tool: target-aware transforms, the plugin content translator, and the build strategies behind aidd translate and aidd sync. CX Codex +1 ★ 571repo stars tools Defines AI assistant and IDE profiles, build contracts, and capability interfaces under src/contexts/tools/ in the framework. CX Codex +1 ★ 571repo stars 00-async-dev 00-async-dev is a Claude Code skill that takes a task through the async-dev pipeline: repo setup, running a ready issue, and clearing review comments on a PR. CX Codex +1 ★ 571repo stars aidd-qa aidd-qa validates browser acceptance criteria against observable behavior and records short review videos. Useful right before submitting a completed task. CX Codex +1 ★ 571repo stars aidd-telemetry aidd-telemetry is a plugin for Claude Code that tracks token use in Claude Code and Codex sessions, grouped by task, model, or other dimensions. Records stay local. CX Codex +1 ★ 571repo stars aidd-ui aidd-ui is a plugin for the UI/UX direction of the AI-Driven Development framework; in alpha, its only smoke-test skill checks that the plugin loads. CX Codex +1 ★ 571repo stars

Project sponsors

Companies that keep this analytics open