Introducing a new way to review your PRs.

Read the announcement

affaan-m / ecc

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

View on GitHub

30 documents · Updated Nov 20, 2026

docs / installation-and-distribution

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

ChannelMain useLifecycle owner
Claude Code plug-inNative Claude installationClaude Code marketplace and plug-in commands
Codex plug-inNative Codex installationCodex marketplace and plug-in commands
Guided package setupCoordinated Claude, Codex, and Kimi setupECC guided installer plus each host's native controls
Repository or npm installerSelective installs for Claude and other supported hostsECC installer and install state
Legacy Codex syncDeprecated compatibility path for copied files in ~/.codexECC 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

ProfilePurpose
minimalLow-context baseline without the hook runtime
opencodeOpenCode baseline with hooks left opt-in
coreHarness baseline with the hook runtime
developerGeneral engineering setup with language, database, and orchestration support
securityCore setup with security guidance
researchCore setup for research and content work
fullAll 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:

  1. Discover valid install state for the requested targets.
  2. Show the planned paths when --dry-run is used.
  3. Remove only recorded managed content.
  4. Preserve changed or unverifiable content and report a partial result.
  5. 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

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

TriggerConsequenceGuard
An unofficial package, mirror, or plug-in source is usedThe installed code may contain malware and is outside project reviewUse 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 integrityPackage code can still be unsafe even when the version is fixedReview the release source and registry integrity before running package code
A required prerequisite such as Node.js 18+, Git, or Claude Code is missingThe package runner or native Claude setup cannot startCheck the required tool versions before running guided setup
Two install methods are used for one hostDuplicate skills, commands, hooks, or configurationChoose one channel per host and remove the extra layer before reinstalling
A selected module is not supported by the targetThe module is skipped or a dependent selection cannot resolveReview the target-filtered plan before applying it
A plan from the read-only inspector is treated as an exact copy listThe shown operations can differ from the final target-specific apply planUse install.sh --dry-run as the final preview before mutation
An OpenCode install omits its required build stepThe host cannot use the expected plug-in payloadBuild the OpenCode payload before the full target install
OpenCode scripts have an edited or missing module boundaryECC refuses the migration instead of changing the meaning of user scriptsGive user scripts their own package scope or restore the recorded boundary before retrying
Automatic update finds an untrusted or mixed repository rootThe update stops instead of applying a possibly unsafe or inconsistent sourceUse one official ECC checkout and pass it explicitly when needed
A user-owned file exists at a planned destinationThe install skips it and does not claim it in install stateMove the file or choose another destination before rerunning
A user edits an ECC-managed fileUpgrade or uninstall retains the file and reports a partial resultReview install state and use the dry-run path before removal
A selected module stops shipping a previously managed fileThe old file can become an orphan or remain in the state ledgerReconcile 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 symlinkECC stops tracking it but preserves it for manual reviewRestore or remove the file manually after reviewing the orphan warning
A planned path passes through a symlink or changes during removalThe write or delete is refused to avoid acting outside the target scopeUse a regular directory tree and rerun after the path is stable
Native and copied Codex installs are mixedTwo configuration layers can conflict and cleanup paths divergeUse the native plug-in or the legacy sync path, not both
A Claude manual plug-in and managed file install overlapPlugin-owned and ECC-managed content can conflict or make cleanup unclearUse one Claude distribution method per scope and review the inventory before removal
A Claude install-state record is malformed or points outside its target rootLifecycle discovery rejects the record instead of safely managing the installKeep install state valid and within the declared Claude home or project root
A Claude plug-in install is expected to provide rulesECC rules are absent from the hostAdd only the required rule packs through the supported rules path
Guided install is run without required non-interactive choicesThe command refuses to mutate a host or cannot confirm the intended scopeSet the required harness, scope, hook, profile, and confirmation options
Legacy language arguments are combined with manifest selectionsThe request is rejected rather than producing an ambiguous installUse either legacy compatibility selection or profile/module/component selection
Hook runtime is selected without an explicit hook decisionThe plan is not safe to apply because host automation consent is unclearUse --enable-hooks or --no-hooks as required by the plan
A target-specific transform receives invalid source metadataThe install stops before writing adapted contentKeep required agent metadata valid and use the target's supported content shape

Key files

FileWhy to read it
README.mdUser-facing distribution choices, official sources, supported hosts, prerequisites, and upgrade or removal guidance
package.jsonPackage identity, release version, published file boundary, command-line entry points, and package build entry point
install.shPOSIX entry point for the package installer and cross-platform package-root setup
install.ps1Windows entry point for the package installer
scripts/install-apply.jsInstaller request surface, target list, selection modes, plan preview, and state application boundary
scripts/install-plan.jsRead-only inspection of profiles, modules, components, and target-filtered plans
scripts/install-guided.jsGuided Claude, Codex, and Kimi setup choices and confirmation boundary
scripts/auto-update.jsSaved-request reconstruction, repository validation, source refresh, and reinstall summary
scripts/…/request.jsRequest modes, selection validation, locale rules, and hook-consent requirements
scripts/…/plan.jsTarget plan materialization, source version capture, content transforms, and operation projection
scripts/…/apply.jsSafe plan application, host configuration updates, state publication, and migration checkpoints
scripts/…/ownership-guard.jsBoundary between user-owned files and ECC-managed files during install and failure recovery
scripts/…/contained-fs.jsTrusted-root writes, reads, and removals that do not follow unsafe paths
scripts/…/stale-operations-reconciliation.jsSelective-upgrade cleanup for files no longer produced by a selected module
scripts/…/content-transform.jsTarget-specific content adaptation rules
scripts/…/copilot-agent.jsCopilot agent metadata boundary and frontmatter adaptation
scripts/…/opencode-script-boundary.jsOpenCode script scope protection during package-boundary changes
scripts/…/json-ops.jsShared JSON merge and managed-subset removal rules
scripts/…/plugin-namespace.jsTranslation from plug-in names to manual Claude file names
scripts/…/registry.jsHost adapter boundary and target planning contract
scripts/…/install-executor.jsConversion from target plans into managed file or configuration operations
scripts/…/install-lifecycle.jsDiscovery, validation, repair, and ownership-based removal lifecycle
scripts/…/inventory.jsClaude install inventory, current and legacy plug-in recognition, and overlap checks
scripts/list-installed.jsInspection of the persistent install-state view
scripts/uninstall.jsRemoval command surface, canonical state reconciliation, and legacy Codex cleanup switch
manifests/install-profiles.jsonNamed bundles for common installation goals
manifests/install-components.jsonUser-facing component families and their module mapping
manifests/install-modules.jsonInstallable units, target support, dependencies, and module metadata
schemas/install-state.schema.jsonContract for the state used by upgrade, repair, and uninstall