CATLX — SILEXIS Module System
This skill owns the module lifecycle: how any CATLX capability becomes a versioned, self-describing
Module — extracted, analyzed, built, packaged, and registered. SILEXIS is an OS-level design language
adopted as native CATLX subsystems (not bolted-on plugins).
Canonical detail: ../knowledge/references/silexis-and-routing.md (§3.1–3.2), plus the manifest
template ../examples (see ../templates/module-manifest.json). Load on demand.
Purpose
Every capability is encapsulated in a Module: a versioned, self-describing unit of logic with a
manifest, an API contract, and declared resource requirements. This skill covers the pipeline that takes a
candidate in /modules/staging and promotes it into /modules/registry and finally /modules/installed.
When to activate
- User asks how CATLX organizes modules, or how a new capability becomes a module.
- Configuring the module registry, manifests, versioning, or dependency graphs.
- Debugging module extraction/analysis/build/packaging.
- Understanding capability tokens (e.g.
catlx.core.memory.episodic).
What this skill handles
- Module Extraction — watch
/modules/staging; on a valid module.manifest.json, run dependency
analysis, interface-contract validation, API-surface extraction, and promotion to /modules/registry.
- Module Analysis — multi-pass static analysis: declared vs actual dependencies, resource benchmarks
under simulated T0/T1/T2, security-surface analysis (network, file, subprocess), capability-contract
completeness.
- Module Building — compile into a distributable artifact. On Windows: an Electron-compatible
CommonJS bundle (+ native Node addon if native bindings required). Build uses esbuild (speed) +
Rollup (final optimization).
- Module Packaging — package contains: compiled bundle, manifest, capability declaration file,
migration script, rollback script, API schema file (JSON Schema), optional Docker Compose fragment.
- Module Registry — file-backed SQLite at
/data/registries/modules.db; REST API on localhost:7700
consumed by the Electron shell, CLI, and Plugin Marketplace. Fields: module_id, version,
capabilities, dependencies, runtime_state, install_path, checksum, compatibility_tier.
Registry schema (exact)
| Field |
Description |
module_id |
catlx.core.memory.episodic |
version |
Semver 2.4.1 |
capabilities |
JSON array of capability tokens |
dependencies |
Directed dependency list with version constraints |
runtime_state |
active | suspended | errored | updating |
install_path |
Relative: /modules/installed/memory.episodic |
checksum |
SHA-256 of package bundle at install time |
compatibility_tier |
Min tier: 0 | 1 | 2 | 3 |
Requirements / constraints
- R4 (file-backed registries + WAL): the registry is never held exclusively in memory; writes are
transactional with a WAL.
- R9 (modularity): every subsystem is a replaceable, isolated module.
- Registry writes are crash-safe; on recovery the WAL replays before any read.
Canonical knowledge it reads
../knowledge/references/silexis-and-routing.md · ../knowledge/references/folder-structure.md ·
../knowledge/rules/architectural-rules.md · ../knowledge/references/data-registries.md.
Delegation
- Where/when a module runs + fallback → delegate to
catlx-capability-routing
(skill({ name: "catlx-capability-routing" })).
- Docker-hosted modules/containers → delegate to
catlx-docker
(skill({ name: "catlx-docker" })).
- Plugin packaging/registry (distinct from modules) → delegate to
catlx-plugin-ecosystem
(skill({ name: "catlx-plugin-ecosystem" })).
- Module registry REST client usage → note the registry is consumed by
catlx-electron-shell and
catlx-capability-routing.
Edge cases & warnings
- A module with an invalid/unsigned package must not be promoted. The analyzer also rejects modules whose
declared capabilities exceed their real implementation.
- Native Node addons must be built for the target Windows architecture; a mismatch breaks loading.
- Version constraints enforce the dependency graph; do not relax them silently.
runtime_state: errored modules must be excluded from scheduling until re-validated.
Component lifecycle policy (reuse → install → adapt → create)
NEVER create a new component as the default. Before building/creating anything (a sub-skill, dependency,
reference, workflow, helper, adapter, or template), check, in order:
- Reuse an existing local component (resolve aliases/equivalent capabilities first) — reuse, don't rebuild.
- Use an already-registered component from the registry.
- Install a suitable existing, trusted, supported component → validate → register → connect to the graph → use.
- Adapt an existing compatible component via a small persistent adapter/wrapper instead of re-creating it.
- Create only as last resort — then make it permanent immediately: stable id, canonical location, register,
add to the capability index + dependency graph, add provenance, use, and allow future reuse.
- Never reorganise/recreate already-generated components (no
Skill X 2 / new / temp variants); extend the
existing one. Never create a second competing knowledge source; connect back to the canonical knowledge/ layer.
Promote any reusable artifact out of /tmp/scratch into the permanent ecosystem.
Full policy: ../knowledge/rules/component-lifecycle.md.
Source / provenance
- Source: PART III §3.1–3.2 (SILEXIS concept, extraction, analysis, building, packaging, registry).
- Inferred/adapted: Windows CommonJS + native-addon artifact (Linux/Docker OCI-layer description not
applied to this Windows-only conversion). The registry schema is preserved exactly.
1---2> Mirror copy of `skills\catlx-core\catlx-silexis-modules\SKILL.md` (canonical content lives in `catlx-core`). Kept at the repository root only for registry-path compatibility. Edit the canonical copy, not this file.3name: catlx-silexis-modules4description: "Handles the SILEXIS module system in CATLX: module extraction, analysis, building, packaging, and the file-backed module registry (SQLite, REST on localhost:7700). Covers module manifests, capability declarations, dependency graphs, checksums, and usage across build artifacts. Use when the user asks about modules, the module registry, module lifecycle, manifest/API-contract validation, packaging, or how a capability becomes an independently versioned module."5metadata:6 catlx: subsystem7 category: architecture8 subsystem: SILEXIS_Module_System9 capability: module-lifecycle10 version: "1.0.0"11 source: https://skillmd.com/skills/samraddhashrivastavatech/catlx-silexis-modules12 upstream: "PART III §3.1-3.2"13 aliases: "modules, module system, module registry, module lifecycle, silexis, capability tokens, packaging"14 depends-on: "catlx-capability-routing"15---1617# CATLX — SILEXIS Module System1819This skill owns the **module lifecycle**: how any CATLX capability becomes a versioned, self-describing20Module — extracted, analyzed, built, packaged, and registered. SILEXIS is an OS-level design language21adopted as native CATLX subsystems (not bolted-on plugins).2223> Canonical detail: `../knowledge/references/silexis-and-routing.md` (§3.1–3.2), plus the manifest24> template `../examples` (see `../templates/module-manifest.json`). Load on demand.2526---2728## Purpose2930Every capability is encapsulated in a **Module**: a versioned, self-describing unit of logic with a31manifest, an API contract, and declared resource requirements. This skill covers the pipeline that takes a32candidate in `/modules/staging` and promotes it into `/modules/registry` and finally `/modules/installed`.3334## When to activate3536- User asks how CATLX organizes modules, or how a new capability becomes a module.37- Configuring the module registry, manifests, versioning, or dependency graphs.38- Debugging module extraction/analysis/build/packaging.39- Understanding capability tokens (e.g. `catlx.core.memory.episodic`).4041## What this skill handles42431. **Module Extraction** — watch `/modules/staging`; on a valid `module.manifest.json`, run dependency44 analysis, interface-contract validation, API-surface extraction, and promotion to `/modules/registry`.452. **Module Analysis** — multi-pass static analysis: declared vs actual dependencies, resource benchmarks46 under simulated T0/T1/T2, security-surface analysis (network, file, subprocess), capability-contract47 completeness.483. **Module Building** — compile into a distributable artifact. On **Windows**: an Electron-compatible49 CommonJS bundle (+ native Node addon if native bindings required). Build uses **esbuild** (speed) +50 **Rollup** (final optimization).514. **Module Packaging** — package contains: compiled bundle, manifest, capability declaration file,52 migration script, rollback script, API schema file (JSON Schema), optional Docker Compose fragment.535. **Module Registry** — file-backed SQLite at `/data/registries/modules.db`; REST API on `localhost:7700`54 consumed by the Electron shell, CLI, and Plugin Marketplace. Fields: `module_id`, `version`,55 `capabilities`, `dependencies`, `runtime_state`, `install_path`, `checksum`, `compatibility_tier`.5657## Registry schema (exact)5859| Field | Description |60|---|---|61| `module_id` | `catlx.core.memory.episodic` |62| `version` | Semver `2.4.1` |63| `capabilities` | JSON array of capability tokens |64| `dependencies` | Directed dependency list with version constraints |65| `runtime_state` | `active \| suspended \| errored \| updating` |66| `install_path` | Relative: `/modules/installed/memory.episodic` |67| `checksum` | SHA-256 of package bundle at install time |68| `compatibility_tier` | Min tier: 0 \| 1 \| 2 \| 3 |6970## Requirements / constraints7172- **R4 (file-backed registries + WAL):** the registry is never held exclusively in memory; writes are73 transactional with a WAL.74- **R9 (modularity):** every subsystem is a replaceable, isolated module.75- Registry writes are crash-safe; on recovery the WAL replays before any read.7677## Canonical knowledge it reads7879`../knowledge/references/silexis-and-routing.md` · `../knowledge/references/folder-structure.md` ·80`../knowledge/rules/architectural-rules.md` · `../knowledge/references/data-registries.md`.8182## Delegation8384- **Where/when a module runs + fallback** → delegate to `catlx-capability-routing`85 (`skill({ name: "catlx-capability-routing" })`).86- **Docker-hosted modules/containers** → delegate to `catlx-docker`87 (`skill({ name: "catlx-docker" })`).88- **Plugin packaging/registry (distinct from modules)** → delegate to `catlx-plugin-ecosystem`89 (`skill({ name: "catlx-plugin-ecosystem" })`).90- **Module registry REST client usage** → note the registry is consumed by `catlx-electron-shell` and91 `catlx-capability-routing`.9293## Edge cases & warnings9495- A module with an invalid/unsigned package must not be promoted. The analyzer also rejects modules whose96 declared capabilities exceed their real implementation.97- Native Node addons must be built for the target Windows architecture; a mismatch breaks loading.98- Version constraints enforce the dependency graph; do not relax them silently.99- `runtime_state: errored` modules must be excluded from scheduling until re-validated.100101## Component lifecycle policy (reuse → install → adapt → create)102103**NEVER create a new component as the default.** Before building/creating anything (a sub-skill, dependency,104reference, workflow, helper, adapter, or template), check, in order:1051. **Reuse** an existing local component (resolve aliases/equivalent capabilities first) — reuse, don't rebuild.1062. **Use** an already-registered component from the registry.1073. **Install** a suitable existing, trusted, supported component → validate → register → connect to the graph → use.1084. **Adapt** an existing compatible component via a small persistent adapter/wrapper instead of re-creating it.1095. **Create only as last resort** — then make it permanent immediately: stable id, canonical location, register,110 add to the capability index + dependency graph, add provenance, use, and allow future reuse.1116. Never reorganise/recreate already-generated components (no `Skill X 2` / `new` / `temp` variants); extend the112 existing one. Never create a second competing knowledge source; connect back to the canonical `knowledge/` layer.113 Promote any reusable artifact out of `/tmp`/scratch into the permanent ecosystem.114115> Full policy: `../knowledge/rules/component-lifecycle.md`.116117## Source / provenance118119- **Source:** PART III §3.1–3.2 (SILEXIS concept, extraction, analysis, building, packaging, registry).120- **Inferred/adapted:** Windows CommonJS + native-addon artifact (Linux/Docker OCI-layer description not121 applied to this Windows-only conversion). The registry schema is preserved exactly.