Installation and distribution
ECC is distributed as a versioned package and as native plug-ins for supported agent hosts. Its installation system selects a host target, resolves a profile or a set of components into compatible modules, and records the files it manages so later upgrades and removal can stay within ECC-owned boundaries.
Distribution channels
ECC reaches users through several related channels. The GitHub repository is the source package for script-based installs and local development. The public ecc-universal npm package provides the package-runner surface, while ecc-agentshield is an official npm package for the separate AgentShield security tool. Native plug-ins are available through the Claude Code and Codex marketplaces. The guided package flow can configure Claude, Codex, and Kimi in one reviewed operation. Official package and plug-in sources are listed in the user guide. package.json, README.md, README.md
The channels share ECC content but do not share the same lifecycle controls. A native host plug-in manages its own registration and scope rules. The repository or package installer manages selected files for a host target. Users should choose one method per host because stacking methods can duplicate skills, commands, hooks, or configuration. README.md
| Channel | Main use | Lifecycle owner |
|---|---|---|
| Claude Code plug-in | Native Claude installation | Claude Code marketplace and plug-in commands |
| Codex plug-in | Native Codex installation | Codex marketplace and plug-in commands |
| Guided package setup | Coordinated Claude, Codex, and Kimi setup | ECC guided installer plus each host's native controls |
| Repository or npm installer | Selective installs for Claude and other supported hosts | ECC installer and install state |
| Legacy Codex sync | Deprecated compatibility path for copied files in ~/.codex | ECC legacy sync cleanup |
Native plug-ins
The native Claude path registers the ecc@ecc plug-in. The native Codex path adds the ECC marketplace entry and then enables the same short plug-in name. Codex keeps one enabled plug-in state in the active CODEX_HOME, while Claude supports its own scope model. README.md, README.md, .codex-plugin/README.md
Native plug-ins are not equivalent to manual file installs. Claude plug-ins do not distribute ECC rules, so users who need rules must add the chosen rule packs separately. Codex owns plug-in hook trust and review. These boundaries mean that plug-in setup and installer setup must not be treated as two layers of one install. README.md, README.md, .codex-plugin/README.md
Claude lifecycle discovery checks both managed home or project installs and manually installed plug-in locations. It recognizes the current ecc@ecc identity and older ECC plug-in identities, then flags managed content that overlaps plug-in paths so the two distribution modes remain separate during cleanup. scripts/…/inventory.js, scripts/…/inventory.js, scripts/…/inventory.js
References: README.md• L282-307 README.md• L349-360 .codex-plugin/README.md• L24-60 .codex-plugin/README.md• L62-78 scripts/…/inventory.js• L8-13 scripts/…/inventory.js• L45-67 scripts/…/inventory.js• L108-141
Script package
The script package is the common path for selective, target-aware installation. install.sh is the POSIX entry point and install.ps1 is the Windows PowerShell entry point. Both resolve the package root and pass the request to the Node installer. The shell entry point also follows symlinked package commands, installs missing checkout dependencies without running dependency scripts, and converts paths for MSYS2 or Git Bash before Node starts. install.sh, install.ps1
The public package is named ecc-universal and publishes the content needed by the supported host adapters. Its published file boundary includes host assets, manifests, schemas, scripts, skills, and the OpenCode distribution. The package exposes the ecc, ecc-install, and related command-line entry points. Users can run the same guided package through npm, pnpm, Yarn 2+, or Bun. The package requires Node.js 18 or newer. Its package step builds the OpenCode payload before publication. The documented repository release is ECC 2.2.3. This makes a tagged package suitable for repeatable installs, while a repository checkout remains useful when an engineer needs a local or unreleased source. package.json, package.json, package.json, package.json, README.md, README.md
The package also carries the shared install helpers that plan, adapt, and safely apply target content. Publication therefore needs to include both the user-facing entry points and the files required by the selected target flows. package.json, package.json
References: install.sh• L1-34 install.ps1• L1-53 package.json• L1-4 package.json• L53-113 package.json• L150-157 package.json• L466-504 package.json• L535-550 README.md• L163-216 README.md• L384-412 README.md• L805-813
Installation model
The installer treats a host as a target and maps selected ECC content into that host's home or project configuration. The current target set covers Claude, Cursor, Antigravity, Codex, Gemini, OpenCode, CodeBuddy, JoyCode, Qwen, Zed, Hermes, OpenClaw, Kimi, and Adal. A target adapter defines the host root and the target-specific form of the selected content. scripts/install-apply.js, scripts/…/registry.js
Home targets affect a user's shared host setup. Project targets keep the setup with one repository. This distinction lets the same ECC capability follow a user across projects or remain limited to a project where it is needed. The installer writes an install-state record beside the target so the lifecycle tools can find the correct scope later. scripts/…/helpers.js, schemas/install-state.schema.json
GitHub Copilot support is provided through repository instruction and prompt files rather than a managed ECC target. Hosts without a native ECC target can use a manual adaptation path, but that path does not provide the same hook or skill discovery behavior as a native adapter. README.md
The install request becomes a plan before it changes files. The plan resolves selections, checks dependencies and target support, applies target-specific exclusions, and produces file or configuration operations. A dry run exposes the plan without copying files. The separate plan inspector lists profiles, modules, and components or resolves a target-filtered selection without mutating the target. scripts/…/plan.js, scripts/install-apply.js, scripts/install-plan.js
The installation flow has these broad stages:
flowchart LR
A[Package or checkout] --> B[Select target]
B --> C[Select profile or components]
C --> D[Resolve modules and dependencies]
D --> E[Plan target operations]
E --> F{Dry run?}
F -->|Yes| G[Show plan]
F -->|No| H[Apply files and config]
H --> I[Write install state]
Host targets
The target adapters preserve one selection model while respecting host differences. Claude can use a shared home target or a project target. Other targets use either their native home or project location. Some hosts need merged JSON configuration or a host-specific content shape, so target support can skip a module even when that module exists in the selected profile. scripts/…/registry.js, scripts/…/claude-home.js, scripts/…/kimi-project.js
OpenCode is a notable target boundary. Its default profile omits the hook runtime until the user opts in. Its plug-in payload also needs to be built before a full OpenCode install can be used. The installer preserves the host's script module boundary when it changes the OpenCode scripts area, and it refuses to reinterpret user scripts when that boundary is missing or edited. scripts/…/install-manifests.js, scripts/…/opencode-script-boundary.js, README.md
References: scripts/install-apply.js• L35-63 scripts/…/plan.js• L258-360 scripts/…/registry.js• L16-31 scripts/…/registry.js• L47-80 scripts/…/helpers.js• L256-285 scripts/…/claude-home.js• L12-55 scripts/…/kimi-project.js• L47-54 scripts/…/install-manifests.js• L145-155 scripts/…/opencode-script-boundary.js• L51-109 README.md• L384-416 README.md• L396-400
Guided harness setup
The guided package installer has two related paths. The setup command focuses on Claude plug-in setup, scope changes, and hook-profile changes. The multi-harness guided install lets a user select Claude, Codex, and Kimi, shows each channel and destination, preflights the choices, and asks for one final confirmation. Advanced managed adapters remain available through explicit target selection until their guided lifecycle support is complete. README.md, scripts/install-guided.js
The guided path does not install or authenticate provider CLIs. Claude hook profiles control automatic behavior, Codex keeps its own hook trust review, and Kimi receives managed project content without ECC hooks. These choices keep host-owned controls separate from ECC content setup. scripts/install-guided.js, scripts/install-guided.js, README.md
References: README.md• L168-263 scripts/install-guided.js• L24-55 scripts/install-guided.js• L203-219 scripts/install-guided.js• L300-322
Profile selection
A profile is a named bundle of modules for a common operating goal. Profiles keep a first install simple while allowing the same resolver to produce a smaller or more specialized setup. The main profiles range from low-context and core baselines to developer, security, research, OpenCode, and full selections. manifests/install-profiles.json
| Profile | Purpose |
|---|---|
minimal | Low-context baseline without the hook runtime |
opencode | OpenCode baseline with hooks left opt-in |
core | Harness baseline with the hook runtime |
developer | General engineering setup with language, database, and orchestration support |
security | Core setup with security guidance |
research | Core setup for research and content work |
full | All currently classified modules |
An explicit profile is optional when a request names modules or components. If no selection is supplied, OpenCode receives its target-specific default profile. This keeps target defaults useful without making a host-specific default override an explicit user choice. scripts/…/install-manifests.js
References: manifests/install-profiles.json• L1-103 scripts/…/install-manifests.js• L550-570
Component selection
A component is the user-facing selection unit. Its ID names a family such as baseline, language, framework, capability, agent, skill, or locale. Each component points to one or more modules, so a request can express intent at a useful level while the installer still resolves the smaller units required for a target. manifests/install-components.json, manifests/install-components.json, schemas/install-components.schema.json
A module is an installable content group with a kind, source paths, supported targets, dependencies, default status, cost, and stability. The resolver expands selected components into modules, adds dependencies, filters modules that the target cannot support, and rejects an exclusion that would break a dependency. manifests/install-modules.json, manifests/install-modules.json, schemas/install-modules.schema.json, scripts/…/install-manifests.js
Users can combine a profile with --with components and --without components. They can also name module IDs directly, select individual skills, install a supported locale for Claude, or load an ecc-install.json request. The request must contain a real profile, module, component, or legacy language selection. Legacy language arguments cannot be mixed with manifest selections. Hook consent is also explicit when a plan includes the hook runtime. scripts/…/request.js, scripts/…/request.js, scripts/install-apply.js
The install command applies the resolved plan, while scripts/install-plan.js can list the available selection units or inspect a plan in human-readable or JSON form without changing files. scripts/install-plan.js, scripts/install-plan.js
References: manifests/install-components.json• L1-58 manifests/install-components.json• L142-187 manifests/install-components.json• L474-672 manifests/install-modules.json• L3-27 manifests/install-modules.json• L153-247 schemas/install-components.schema.json• L15-54 schemas/install-modules.schema.json• L10-106 scripts/…/install-manifests.js• L614-685 scripts/…/request.js• L19-98 scripts/…/request.js• L101-171 scripts/install-apply.js• L24-67 scripts/install-plan.js• L19-47 scripts/install-plan.js• L208-269
Target content adaptation
The installer can reshape shared ECC content when a host uses a different naming or metadata model. This keeps one source selection usable across hosts without copying host-specific names or settings into a target that cannot interpret them. scripts/…/content-transform.js
The main adaptations are:
- Manual Claude copies remove the
ecc:plug-in namespace because manual files use bare names. - Copilot agent copies keep only the frontmatter that Copilot understands and rewrite the supported helper path for the installed project layout.
- Qwen and Antigravity agent copies receive their host-specific frontmatter shape.
- OpenCode hook and skill paths change when the user declines hooks or when the install moves content into the target layout.
These transformations apply to the planned content before it becomes managed target content. Binary files remain byte-preserving when a textual transform does not apply. scripts/…/plan.js, scripts/…/content-transform.js, scripts/…/copilot-agent.js, scripts/…/plugin-namespace.js
References: scripts/…/plan.js• L99-122 scripts/…/plan.js• L288-309 scripts/…/content-transform.js• L8-56 scripts/…/copilot-agent.js• L20-65 scripts/…/plugin-namespace.js• L1-15
Managed content boundaries
ECC protects the boundary between content it owns and files that belong to the user or the host. A new file at a planned destination is preserved rather than overwritten when it is not in the prior install record. A previously managed file can be updated, but a changed configuration file is retained and removed from ECC ownership. scripts/…/ownership-guard.js, scripts/…/ownership-guard.js
Writes and removals stay inside the target root and do not follow unsafe path links. Removal first moves the selected path to a temporary quarantine and checks that it is still the same object before deleting it. This reduces the risk that an install or cleanup action changes a path outside the selected host scope. scripts/…/contained-fs.js, scripts/…/contained-fs.js, scripts/…/contained-fs.js
Shared JSON configuration follows the same boundary. Install operations merge managed values into an existing object, while lifecycle operations can identify and remove only the managed JSON subset instead of replacing unrelated host settings. scripts/…/json-ops.js, scripts/…/json-ops.js
References: scripts/…/ownership-guard.js• L26-38 scripts/…/ownership-guard.js• L40-89 scripts/…/ownership-guard.js• L140-168 scripts/…/contained-fs.js• L8-49 scripts/…/contained-fs.js• L52-85 scripts/…/contained-fs.js• L210-261 scripts/…/json-ops.js• L85-99 scripts/…/json-ops.js• L121-163
Upgrade lifecycle
An upgrade is a new install plan applied to an existing target. The plan can change the selected profile, add or remove components, or refresh the source version. The installer records the request, resolved modules, source version, and operations so later tools can inspect what the target should contain. schemas/install-state.schema.json, schemas/install-state.schema.json
For native plug-ins, the host's update command refreshes the host registration or cache. For script installs, rerun the installer with the desired target and selection. The guided package command can also update ECC, change Claude scope, or change its hook profile. Preview the plan first when changing profiles or moving from an older install method. Native Claude and Codex updates remain separate from ECC-managed copied files. README.md, README.md, README.md
The installer uses recorded ownership and content information to avoid treating unrelated host files as ECC files. A changed user file is not silently overwritten during safe repair or removed during uninstall. Older manual layouts can be migrated only when install state gives enough evidence of ECC ownership. README.md, scripts/…/ownership-guard.js, scripts/…/install-lifecycle.js
Automatic updates
The automatic update path finds active install-state records for the current home and project context, identifies the ECC source package, and reapplies each saved request. It can preview the work without fetching or changing files. It refuses an untrusted repository root and stops when active records point to different ECC roots. scripts/auto-update.js, scripts/auto-update.js
This preserves the user's original target, profile, module, component, hook-consent, and legacy-language choices during a source refresh. Legacy-only layouts are reported as migration warnings instead of being updated as if they were current managed installs. scripts/auto-update.js, scripts/auto-update.js
References: schemas/install-state.schema.json• L1-14 schemas/install-state.schema.json• L28-60 schemas/install-state.schema.json• L62-212 scripts/auto-update.js• L84-121 scripts/auto-update.js• L132-161 scripts/auto-update.js• L191-287 scripts/list-installed.js• L42-63 scripts/…/install-lifecycle.js• L148-164 scripts/…/ownership-guard.js• L40-89 README.md• L207-220 README.md• L349-360
Selective upgrade reconciliation
Install state is cumulative so a selective install does not forget modules that remain managed. When a selected module no longer produces one of its old files, the installer removes that stale record from the successful state and deletes the old file only when its recorded content is unchanged. Edited, missing, non-file, or unsafe paths are preserved and reported as orphaned content. scripts/…/stale-operations-reconciliation.js, scripts/…/stale-operations-reconciliation.js, scripts/…/stale-operations-reconciliation.js
The same reconciliation keeps failed installs recoverable. A bridge or checkpoint retains ownership for work already attempted, while the final state publishes only the operations that the new plan still owns. This lets a later repair or uninstall distinguish a failed ECC write from an unrelated user file. scripts/…/apply.js, scripts/…/apply.js
References: scripts/…/stale-operations-reconciliation.js• L10-29 scripts/…/stale-operations-reconciliation.js• L60-125 scripts/…/stale-operations-reconciliation.js• L233-282 scripts/…/apply.js• L784-817 scripts/…/apply.js• L956-999
Removal model
ECC removal is ownership-based. The uninstall command discovers install-state records for the current home and project context, removes managed operations, and removes the state record only when no retained managed files remain. It does not claim every file in a host configuration directory. scripts/uninstall.js, scripts/uninstall.js, scripts/…/install-lifecycle.js
The removal flow is:
- Discover valid install state for the requested targets.
- Show the planned paths when
--dry-runis used. - Remove only recorded managed content.
- Preserve changed or unverifiable content and report a partial result.
- Remove empty managed directories and the state record when cleanup is complete.
Native plug-ins must be removed through their host. A manual rule folder copied outside ECC install state also needs separate review. When no current install state exists, the uninstaller can detect legacy Codex sync artifacts only when their ownership record is present. The explicit legacy mode also supports marker-only cleanup. README.md, scripts/uninstall.js, scripts/uninstall.js, .codex-plugin/README.md
Install state
Install state is the lifecycle record for one target context. It identifies the target root and state path, preserves the original request and module resolution, records the package and manifest versions, and lists the operations that ECC owns. This record is the link between installation, health checks, repair, upgrade, and removal. schemas/install-state.schema.json, schemas/install-state.schema.json, schemas/install-state.schema.json
list-installed reads these records to show the installed target, root, profile, modules, and source version. The installer and uninstaller also project or reconcile this state into the canonical install-state view. This is the first useful check when a host was reset or when several installation methods may have been used. scripts/list-installed.js, scripts/…/apply.js, scripts/uninstall.js
References: schemas/install-state.schema.json• L1-14 schemas/install-state.schema.json• L28-60 schemas/install-state.schema.json• L62-212 scripts/list-installed.js• L42-63 scripts/…/apply.js• L956-967 scripts/uninstall.js• L162-169 scripts/…/install-lifecycle.js• L148-164
Safe removal
Safe removal favors preservation over completeness when ownership is uncertain. Modified managed files and legacy files without verifiable provenance remain in place with a warning. Modified paths are not adopted again by a later install unless the ownership record still proves that ECC may manage them. This protects user changes but can leave a partial installation that needs review before a clean reinstall. scripts/…/install-lifecycle.js, scripts/…/ownership-guard.js, scripts/…/contained-fs.js
References: scripts/uninstall.js• L9-15 scripts/uninstall.js• L97-121 scripts/…/install-lifecycle.js• L1920-2012 scripts/…/ownership-guard.js• L40-89 scripts/…/contained-fs.js• L210-261 .codex-plugin/README.md• L80-93
Related pages
Use Installer orchestration for the shell and JavaScript entry points, guided and planned flows, state application, package-manager setup, and uninstall behavior.
Use Installation manifests and schemas for the component, module, and profile contracts and the validated install-state shape.
Change checklist
When these files or sections are changed, remember to consider these:
- Keep the target and option surfaces aligned across the applying installer, the read-only plan inspector, the request normalizer, the module schema, the target adapter registry, and the supported-target tables in the user guide.
- When changing a profile or component, check module dependencies and target support so a valid selection does not become empty or fail only on one host.
- When changing a destination strategy, preserve the install-state operation contract so upgrade, repair, and uninstall still identify the same managed files.
- When adding a package entry point or native plug-in asset, update the package file list and the matching host distribution path together.
- When changing hook or configuration ownership, check whether the native host owns the setting or whether ECC install state must record it.
- When changing state fields or operation ownership, update the state schema and all lifecycle readers before publishing a package.
- When changing automatic update inputs, keep repository validation and saved-request reconstruction aligned with install-state records.
- When changing guided harness choices, keep the host capability rules separate from the advanced target adapter and provider CLI boundaries.
- When changing plan inspection output, keep human-readable and JSON output consistent with the selection data used by the applying installer.
- When changing package or plug-in distribution paths, keep the official source list, package-runner instructions, and native marketplace guidance aligned.
- When changing guided setup prerequisites or harness coverage, update the package-runner commands and the per-harness lifecycle limits together.
- When changing Claude plug-in IDs, install-state locations, or managed paths, keep current and legacy plug-in recognition and overlap checks aligned with lifecycle cleanup.
- When adding a content transform, keep its target selection, source file type rules, ownership digest, and safe apply path aligned.
- When changing stale-operation rules, preserve the distinction between selected modules, retained operations, unchanged files, and user-edited files.
- When changing path safety or removal behavior, keep root checks, symlink handling, object identity checks, and quarantine cleanup aligned for both writes and deletes.
- When changing OpenCode scripts or package metadata, preserve user module boundaries and the refusal path for edited or unowned scripts.
- When changing JSON merge or removal behavior, ensure managed values do not replace or delete unrelated host settings.
Important failure modes
| Trigger | Consequence | Guard |
|---|---|---|
| An unofficial package, mirror, or plug-in source is used | The installed code may contain malware and is outside project review | Use only the official repository, packages, app, plug-in slug, and website listed in the user guide |
| A version-pinned package is treated as trusted without reviewing its source or registry integrity | Package code can still be unsafe even when the version is fixed | Review the release source and registry integrity before running package code |
| A required prerequisite such as Node.js 18+, Git, or Claude Code is missing | The package runner or native Claude setup cannot start | Check the required tool versions before running guided setup |
| Two install methods are used for one host | Duplicate skills, commands, hooks, or configuration | Choose one channel per host and remove the extra layer before reinstalling |
| A selected module is not supported by the target | The module is skipped or a dependent selection cannot resolve | Review the target-filtered plan before applying it |
| A plan from the read-only inspector is treated as an exact copy list | The shown operations can differ from the final target-specific apply plan | Use install.sh --dry-run as the final preview before mutation |
| An OpenCode install omits its required build step | The host cannot use the expected plug-in payload | Build the OpenCode payload before the full target install |
| OpenCode scripts have an edited or missing module boundary | ECC refuses the migration instead of changing the meaning of user scripts | Give user scripts their own package scope or restore the recorded boundary before retrying |
| Automatic update finds an untrusted or mixed repository root | The update stops instead of applying a possibly unsafe or inconsistent source | Use one official ECC checkout and pass it explicitly when needed |
| A user-owned file exists at a planned destination | The install skips it and does not claim it in install state | Move the file or choose another destination before rerunning |
| A user edits an ECC-managed file | Upgrade or uninstall retains the file and reports a partial result | Review install state and use the dry-run path before removal |
| A selected module stops shipping a previously managed file | The old file can become an orphan or remain in the state ledger | Reconcile the plan; ECC deletes only an unchanged file inside the target root |
| A stale file is edited, lacks a digest, or is reached through a symlink | ECC stops tracking it but preserves it for manual review | Restore or remove the file manually after reviewing the orphan warning |
| A planned path passes through a symlink or changes during removal | The write or delete is refused to avoid acting outside the target scope | Use a regular directory tree and rerun after the path is stable |
| Native and copied Codex installs are mixed | Two configuration layers can conflict and cleanup paths diverge | Use the native plug-in or the legacy sync path, not both |
| A Claude manual plug-in and managed file install overlap | Plugin-owned and ECC-managed content can conflict or make cleanup unclear | Use one Claude distribution method per scope and review the inventory before removal |
| A Claude install-state record is malformed or points outside its target root | Lifecycle discovery rejects the record instead of safely managing the install | Keep install state valid and within the declared Claude home or project root |
| A Claude plug-in install is expected to provide rules | ECC rules are absent from the host | Add only the required rule packs through the supported rules path |
| Guided install is run without required non-interactive choices | The command refuses to mutate a host or cannot confirm the intended scope | Set the required harness, scope, hook, profile, and confirmation options |
| Legacy language arguments are combined with manifest selections | The request is rejected rather than producing an ambiguous install | Use either legacy compatibility selection or profile/module/component selection |
| Hook runtime is selected without an explicit hook decision | The plan is not safe to apply because host automation consent is unclear | Use --enable-hooks or --no-hooks as required by the plan |
| A target-specific transform receives invalid source metadata | The install stops before writing adapted content | Keep required agent metadata valid and use the target's supported content shape |
Key files
| File | Why to read it |
|---|---|
| README.md | User-facing distribution choices, official sources, supported hosts, prerequisites, and upgrade or removal guidance |
| package.json | Package identity, release version, published file boundary, command-line entry points, and package build entry point |
| install.sh | POSIX entry point for the package installer and cross-platform package-root setup |
install.ps1 | Windows entry point for the package installer |
| scripts/install-apply.js | Installer request surface, target list, selection modes, plan preview, and state application boundary |
| scripts/install-plan.js | Read-only inspection of profiles, modules, components, and target-filtered plans |
| scripts/install-guided.js | Guided Claude, Codex, and Kimi setup choices and confirmation boundary |
| scripts/auto-update.js | Saved-request reconstruction, repository validation, source refresh, and reinstall summary |
| scripts/…/request.js | Request modes, selection validation, locale rules, and hook-consent requirements |
| scripts/…/plan.js | Target plan materialization, source version capture, content transforms, and operation projection |
| scripts/…/apply.js | Safe plan application, host configuration updates, state publication, and migration checkpoints |
| scripts/…/ownership-guard.js | Boundary between user-owned files and ECC-managed files during install and failure recovery |
| scripts/…/contained-fs.js | Trusted-root writes, reads, and removals that do not follow unsafe paths |
| scripts/…/stale-operations-reconciliation.js | Selective-upgrade cleanup for files no longer produced by a selected module |
| scripts/…/content-transform.js | Target-specific content adaptation rules |
| scripts/…/copilot-agent.js | Copilot agent metadata boundary and frontmatter adaptation |
| scripts/…/opencode-script-boundary.js | OpenCode script scope protection during package-boundary changes |
| scripts/…/json-ops.js | Shared JSON merge and managed-subset removal rules |
| scripts/…/plugin-namespace.js | Translation from plug-in names to manual Claude file names |
| scripts/…/registry.js | Host adapter boundary and target planning contract |
| scripts/…/install-executor.js | Conversion from target plans into managed file or configuration operations |
| scripts/…/install-lifecycle.js | Discovery, validation, repair, and ownership-based removal lifecycle |
| scripts/…/inventory.js | Claude install inventory, current and legacy plug-in recognition, and overlap checks |
| scripts/list-installed.js | Inspection of the persistent install-state view |
| scripts/uninstall.js | Removal command surface, canonical state reconciliation, and legacy Codex cleanup switch |
| manifests/install-profiles.json | Named bundles for common installation goals |
| manifests/install-components.json | User-facing component families and their module mapping |
| manifests/install-modules.json | Installable units, target support, dependencies, and module metadata |
| schemas/install-state.schema.json | Contract for the state used by upgrade, repair, and uninstall |